Расшифруй аббревиатуру SOLID

Расшифруй аббревиатуру SOLID

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

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

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

# Плохо: класс имеет две ответственности
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
    
    def save_to_db(self):
        # Ответственность 1: управление данными пользователя
        pass
    
    def send_email(self):
        # Ответственность 2: отправка писем
        pass

# Хорошо: разделение ответственности
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

class EmailSender:
    def send(self, user):
        pass

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

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

# Плохо: нужно менять класс для каждого нового типа
class ReportGenerator:
    def generate(self, report_type):
        if report_type == 'pdf':
            # генерировать PDF
            pass
        elif report_type == 'excel':
            # генерировать Excel
            pass

# Хорошо: открыто для расширения
class ReportGenerator:
    def generate(self, formatter):
        return formatter.format()

class PDFFormatter:
    def format(self):
        return "PDF report"

class ExcelFormatter:
    def format(self):
        return "Excel report"

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

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

# Плохо: квадрат нарушает контракт прямоугольника
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def set_width(self, w):
        self.width = w
    
    def set_height(self, h):
        self.height = h

class Square(Rectangle):
    def set_width(self, w):
        self.width = w
        self.height = w  # Нарушение контракта!

# Хорошо: использование композиции или разных иерархий
class Shape:
    pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

class Square(Shape):
    def __init__(self, side):
        self.side = side

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

Множество специализированных интерфейсов лучше, чем один универсальный. Клиент не должен зависеть от интерфейсов, которые он не использует.

# Плохо: один большой интерфейс
class Worker:
    def work(self):
        pass
    
    def eat_lunch(self):
        pass

class Robot(Worker):
    def work(self):
        pass
    
    def eat_lunch(self):
        raise NotImplementedError("Robot doesn't eat")

# Хорошо: разделение интерфейсов
class Workable:
    def work(self):
        pass

class Eatable:
    def eat_lunch(self):
        pass

class Human(Workable, Eatable):
    pass

class Robot(Workable):
    pass

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

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

# Плохо: высокий уровень зависит от низкого
class MySQLDatabase:
    def save(self, data):
        pass

class UserService:
    def __init__(self):
        self.db = MySQLDatabase()  # Жесткая зависимость
    
    def save_user(self, user):
        self.db.save(user)

# Хорошо: зависимость от абстракции
class Database:
    def save(self, data):
        pass

class MySQLDatabase(Database):
    def save(self, data):
        pass

class PostgresDatabase(Database):
    def save(self, data):
        pass

class UserService:
    def __init__(self, db: Database):  # Инъекция зависимости
        self.db = db
    
    def save_user(self, user):
        self.db.save(user)

Практическое значение SOLID

Применение принципов SOLID позволяет:

• Создавать более читаемый и понятный код
• Упростить тестирование (возможность использовать mock'и)
• Облегчить расширение функциональности без изменения существующего кода
• Снизить связанность между компонентами (loose coupling)
• Повысить переиспользуемость кода

SOLID — это не просто набор правил, а философия проектирования, которая делает код более гибким, поддерживаемым и расширяемым.