Основы принципов SOLID

SOLID — это аббревиатура пяти принципов объектно-ориентированного проектирования, которые помогают создавать поддерживаемый, расширяемый и надёжный код.

Краткий обзор

SOLID: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.

S — Single Responsibility (SRP)

Класс должен иметь только одну причину для изменения.

// Плохо: множество ответственности
class User {
  saveToDatabase() { /* DB */ }
  sendEmail() { /* E-Mail */ }
  validateEmail() { /* Validierung */ }
}

// Хорошо: разделение
class User {}
class UserRepository { save(u: User) {} }
class EmailService { send(u: User, msg: string) {} }

O — Open-Closed (OCP)

Открыт для расширения, закрыт для модификации.

// Плохо: нужно менять switch при новом типе
class DiscountCalculator {
  calculate(type: string): number {
    if (type === 'premium') return 0.8;
    if (type === 'vip') return 0.7;
    return 1.0;
  }
}

// Хорошо: Strategy Pattern
interface DiscountStrategy { getFactor(): number; }
class PremiumDiscount implements DiscountStrategy { getFactor() { return 0.8; } }
class VipDiscount implements DiscountStrategy { getFactor() { return 0.7; } }

L — Liskov Substitution (LSP)

Подтипы должны правильно заменять базовые типы.

// Плохо: пингвин не может летать
class Bird { fly() {} }
class Penguin extends Bird { fly() { throw new Error('Cannot fly'); } }

// Хорошо: правильная иерархия
interface Bird { layEgg(): void; }
interface FlyingBird extends Bird { fly(): void; }

I — Interface Segregation (ISP)

Клиент не должен зависеть от методов, которые он не использует.

// Плохо: толстый интерфейс
interface Worker { work(): void; eat(): void; sleep(): void; }

// Хорошо: разделённые интерфейсы
interface Workable { work(): void; }
interface Eatable { eat(): void; }

D — Dependency Inversion (DIP)

Зависеть от абстракций, а не от конкретных реализаций.

// Плохо: прямая зависимость
class OrderService {
  private repo = new MySQLDatabase();
}

// Хорошо: Dependency Injection
interface OrderRepository { save(order: Order): void; }
class OrderService {
  constructor(private repo: OrderRepository) {}
}

Обзор SOLID

Принцип	Значение	Цель
SRP	Single Responsibility	Один класс, одна ответственность
OCP	Open-Closed	Расширяемость без изменения кода
LSP	Liskov Substitution	Подтипы корректно заменяют базовые типы
ISP	Interface Segregation	Маленькие, специфичные интерфейсы
DIP	Dependency Inversion	Абстракция вместо конкретных реализаций

Ключевые моменты

• SOLID как аббревиатура пяти принципов OOP-проектирования
• SRP: одна причина для изменения на класс
• OCP: расширение без модификации (Strategy Pattern)
• LSP: подтипы должны соблюдать контракты
• ISP: много маленьких интерфейсов
• DIP: Dependency Injection, абстракция как зависимость

FAQ

Продолжение в курсе SOLID

Следующий материал в серии SOLID посвящен анализу и проектированию: UML, GRASP, SOLID и качественные цели — как UML-диаграммы, GRASP-паттерны и принципы SOLID работают вместе в архитектуре программного обеспечения.

Источники

1. https://en.wikipedia.org/wiki/SOLID
2. https://www.oreilly.com/library/view/clean-code/9780134661742/
3. https://refactoring.guru/design-patterns/solid-principles

Рекомендуемые книги по качеству кода

Если ты хочешь больше узнать о SOLID, Clean Code и качестве программного обеспечения, мы рекомендуем следующие книги: