Что такое принцип открытости/закрытости (Open-Closed Principle)?

Что такое принцип открытости/закрытости (Open-Closed Principle)?

Открытый/Закрытый принцип (Open-Closed Principle, OCP) — это второй принцип SOLID. Он гласит:

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

Это означает:

• Легко добавлять новую функциональность
• Не нужно менять существующий код
• Минимизируем риск сломать что-то старое при добавлении нового

Проблема без OCP

Представь платёжную систему, которая первоначально поддерживала только Credit Card:

# ❌ Плохо: нарушение OCP
class PaymentProcessor:
    def process_payment(self, payment_method: str, amount: float) -> bool:
        if payment_method == "credit_card":
            print(f"Processing ${amount} via Credit Card")
            return True
        elif payment_method == "paypal":
            print(f"Processing ${amount} via PayPal")
            return True
        elif payment_method == "stripe":
            print(f"Processing ${amount} via Stripe")
            return True
        # Завтра появится новый способ оплаты?
        # Нужно изменять класс снова!
        # С каждым изменением растёт риск сломать что-то старое

Проблемы:

1. Каждый раз добавляем новый elif
2. Класс становится всё больше и больше
3. Высокий риск регрессии (сломать старый код при добавлении нового)
4. Сложный для тестирования
5. Нарушает Single Responsibility (один класс отвечает за слишком много)

Решение через OCP

Ключевая идея: использовать абстракцию (интерфейс) и наследование

from abc import ABC, abstractmethod

# Абстракция (закрыта для модификации)
class PaymentMethod(ABC):
    @abstractmethod
    def process(self, amount: float) -> bool:
        pass
    
    @abstractmethod
    def validate(self) -> bool:
        pass

# Реализации (открыты для расширения)
class CreditCardPayment(PaymentMethod):
    def __init__(self, card_number: str, cvv: str):
        self.card_number = card_number
        self.cvv = cvv
    
    def validate(self) -> bool:
        return len(self.card_number) == 16 and len(self.cvv) == 3
    
    def process(self, amount: float) -> bool:
        if not self.validate():
            raise ValueError("Invalid card")
        print(f"Processing ${amount} via Credit Card")
        return True

class PayPalPayment(PaymentMethod):
    def __init__(self, email: str):
        self.email = email
    
    def validate(self) -> bool:
        return "@" in self.email
    
    def process(self, amount: float) -> bool:
        if not self.validate():
            raise ValueError("Invalid email")
        print(f"Processing ${amount} via PayPal")
        return True

class StripePayment(PaymentMethod):
    def __init__(self, token: str):
        self.token = token
    
    def validate(self) -> bool:
        return len(self.token) > 10
    
    def process(self, amount: float) -> bool:
        if not self.validate():
            raise ValueError("Invalid token")
        print(f"Processing ${amount} via Stripe")
        return True

# Процессор (теперь закрыт для модификации!)
class PaymentProcessor:
    def process_payment(self, method: PaymentMethod, amount: float) -> bool:
        """Работает с любым PaymentMethod"""
        return method.process(amount)

# Использование
if __name__ == "__main__":
    processor = PaymentProcessor()
    
    card = CreditCardPayment("1234567890123456", "123")
    processor.process_payment(card, 100.00)
    
    paypal = PayPalPayment("user@example.com")
    processor.process_payment(paypal, 50.00)
    
    stripe = StripePayment("sk_test_123456789")
    processor.process_payment(stripe, 75.00)

Завтра нужна Bitcoin оплата? Просто добавь новый класс!

class BitcoinPayment(PaymentMethod):
    def __init__(self, wallet_address: str):
        self.wallet_address = wallet_address
    
    def validate(self) -> bool:
        return len(self.wallet_address) == 34
    
    def process(self, amount: float) -> bool:
        if not self.validate():
            raise ValueError("Invalid wallet")
        print(f"Processing {amount} BTC")
        return True

# PaymentProcessor НЕ менялся!
# Просто используем новый класс
bitcoin = BitcoinPayment("1A1z7agoat3Z7Xd8Wj...")
processor.process_payment(bitcoin, 0.01)

Ещё примеры OCP

Пример 2: Система уведомлений

# ❌ Без OCP
class Notifier:
    def send(self, message: str, type: str):
        if type == "email":
            # Отправить email
            pass
        elif type == "sms":
            # Отправить SMS
            pass
        elif type == "push":
            # Отправить push
            pass

# ✅ С OCP
from abc import ABC, abstractmethod

class NotificationChannel(ABC):
    @abstractmethod
    def send(self, message: str) -> bool:
        pass

class EmailNotification(NotificationChannel):
    def __init__(self, email: str):
        self.email = email
    
    def send(self, message: str) -> bool:
        print(f"Sending email to {self.email}: {message}")
        return True

class SMSNotification(NotificationChannel):
    def __init__(self, phone: str):
        self.phone = phone
    
    def send(self, message: str) -> bool:
        print(f"Sending SMS to {self.phone}: {message}")
        return True

class PushNotification(NotificationChannel):
    def __init__(self, device_id: str):
        self.device_id = device_id
    
    def send(self, message: str) -> bool:
        print(f"Sending push to {self.device_id}: {message}")
        return True

class Notifier:
    def __init__(self, channel: NotificationChannel):
        self.channel = channel
    
    def notify(self, message: str) -> bool:
        return self.channel.send(message)

# Использование
notifier = Notifier(EmailNotification("user@example.com"))
notifier.notify("Hello!")

# Завтра добавим WhatsApp? Просто создаём новый класс!
class WhatsAppNotification(NotificationChannel):
    def __init__(self, phone: str):
        self.phone = phone
    
    def send(self, message: str) -> bool:
        print(f"Sending WhatsApp to {self.phone}: {message}")
        return True

# Notifier не менялся!
notifier = Notifier(WhatsAppNotification("+1234567890"))
notifier.notify("Hello!")

Пример 3: Система отчётов

# ✅ OCP: каждый формат — отдельный класс
from abc import ABC, abstractmethod

class ReportFormatter(ABC):
    @abstractmethod
    def format(self, data: dict) -> str:
        pass

class PDFFormatter(ReportFormatter):
    def format(self, data: dict) -> str:
        return f"<PDF>{data}</PDF>"

class HTMLFormatter(ReportFormatter):
    def format(self, data: dict) -> str:
        return f"<html><body>{data}</body></html>"

class JSONFormatter(ReportFormatter):
    import json
    
    def format(self, data: dict) -> str:
        return json.dumps(data)

class ReportGenerator:
    def __init__(self, formatter: ReportFormatter):
        self.formatter = formatter
    
    def generate(self, data: dict) -> str:
        return self.formatter.format(data)

# Использование
data = {"name": "John", "age": 30}

pdf_report = ReportGenerator(PDFFormatter())
print(pdf_report.generate(data))

json_report = ReportGenerator(JSONFormatter())
print(json_report.generate(data))

Как применить OCP на практике

1. Выдели абстракцию (интерфейс)

   • Что общего у всех реализаций?
   • Что может меняться в будущем?

2. Создай abstract базовый класс или интерфейс

   • Все реализации наследуют от него
   • Переопредеяют abstract методы

3. Используй dependency injection

   • Передавай зависимости через конструктор
   • Не создавай объекты внутри класса

4. Расширяй через наследование, не модификацию

   • Нужна новая функция? Создай новый класс
   • Не меняй существующий код

OCP vs YAGNI (You Aren't Gonna Need It)

Осторожность! Не переусложняй прямо сейчас:

# ❌ Переусложнение (YAGNI)
if len(payment_methods) == 1:
    # Зачем создавать полноценную абстракцию для одного способа?
    # Это потом!
    pass

# ✅ Когда вводить OCP
# Когда появляется ВТОРОЙ способ обработки

Вывод

Открытый/Закрытый принцип помогает:

• Легко добавлять новое без изменения старого
• Снизить риск регрессии
• Упростить тестирование (тестируем каждый класс отдельно)
• Улучшить переиспользуемость кода
• Сделать код более гибким для изменений

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