Принципы SOLID — это пять фундаментальных принципов объектно-ориентированного проектирования (ООП), разработанных для повышения читаемости, расширяемости и сопровождаемости кода. Акроним SOLID расшифровывается как:

• S — Single Responsibility Principle (Принцип единственной ответственности)

• O — Open/Closed Principle (Принцип открытости/закрытости)

• L — Liskov Substitution Principle (Принцип подстановки Барбары Лисков)

• I — Interface Segregation Principle (Принцип разделения интерфейса)

• D — Dependency Inversion Principle (Принцип инверсии зависимостей)

Эти принципы были популяризированы Робертом Мартином (Robert C. Martin, «Дядя Боб») и применяются для разработки гибких и масштабируемых программных систем.

1. Single Responsibility Principle (SRP)

Принцип единственной ответственности гласит:

У класса должна быть только одна причина для изменения.

То есть класс должен выполнять только одну задачу. Если в классе реализовано несколько обязанностей (например, логика работы с данными и логика вывода в UI), то это делает его хрупким при изменениях.

Пример нарушения:

class Report {
void calculate() { /\* ... \*/ }
void print() { /\* ... \*/ } // UI-логика
void saveToFile() { /\* ... \*/ } // Сохранение
}

Правильное решение:

• Вынести print() в отдельный ReportPrinter

• Вынести saveToFile() в ReportSaver

2. Open/Closed Principle (OCP)

Принцип открытости/закрытости гласит:

Программные сущности должны быть открыты для расширения, но закрыты для изменения.

Это значит, что поведение системы должно быть расширяемым без необходимости в модификации существующего кода. Часто реализуется через наследование или делегирование.

Пример нарушения:

class PaymentProcessor {
void process(String type) {
if (type.equals("credit")) { ... }
else if (type.equals("paypal")) { ... }
}
}

Решение с использованием OCP:

interface Payment {
void process();
}
class CreditCardPayment implements Payment { ... }
class PayPalPayment implements Payment { ... }
class PaymentProcessor {
void process(Payment payment) {
payment.process();
}
}

3. Liskov Substitution Principle (LSP)

Принцип подстановки Барбары Лисков:

Объекты подклассов должны быть взаимозаменяемы с объектами базового класса без нарушения правильности работы программы.

Если S — подтип T, то экземпляры T можно заменить на S без нарушения логики.

Пример нарушения:

class Bird {
void fly() { ... }
}
class Ostrich extends Bird {
void fly() {
throw new UnsupportedOperationException();
}
}

Проблема: Ostrich не умеет летать, но Bird требует метод fly().

Решение: Разделить иерархию:

interface Bird { void layEgg(); }
interface FlyingBird extends Bird { void fly(); }
class Ostrich implements Bird { ... }
class Sparrow implements FlyingBird { ... }

4. Interface Segregation Principle (ISP)

Принцип разделения интерфейса:

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

Это означает, что большие интерфейсы нужно разделять на более мелкие, чтобы классы реализовывали только необходимые методы.

Нарушение ISP:

interface Worker {
void work();
void eat();
}
class Robot implements Worker {
void work() { ... }
void eat() { throw new UnsupportedOperationException(); }
}

Решение:

interface Workable { void work(); }
interface Eatable { void eat(); }
class Human implements Workable, Eatable { ... }
class Robot implements Workable { ... }

5. Dependency Inversion Principle (DIP)

Принцип инверсии зависимостей:

Модули верхнего уровня не должны зависеть от модулей нижнего уровня. Оба должны зависеть от абстракций.

Также:

Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.

Это позволяет ослабить связанность между компонентами системы, делает их более гибкими и тестируемыми.

Нарушение DIP:

class LightBulb { void turnOn(); }
class Switch {
private LightBulb bulb = new LightBulb();
void operate() {
bulb.turnOn();
}
}

Решение — ввести абстракцию:

interface Switchable { void turnOn(); }
class LightBulb implements Switchable { ... }
class Switch {
private Switchable device;
public Switch(Switchable device) {
this.device = device;
}
void operate() {
device.turnOn();
}
}

Теперь Switch можно использовать с любым устройством, реализующим Switchable.

Дополнительные замечания

• SOLID-принципы повышают тестируемость и переиспользуемость кода.

• Они особенно полезны при разработке архитектуры больших приложений.

• Часто реализуются совместно с такими паттернами, как фабрика, стратегия, декоратор, адаптер.

• Следование им упрощает поддержку кода, облегчает рефакторинг и добавление новых фич.