В чем разница между композицией и наследованным в Python?

Разница между композицией и наследованием в Python

Это один из самых важных архитектурных вопросов в ООП. Выбор между композицией и наследованием определяет гибкость, тестируемость и долгосрочность вашего кода. Многие опытные разработчики предпочитают композицию.

Что такое наследование?

Наследование — это когда класс-потомок получает все свойства и методы класса-родителя через отношение "является" (is-a relationship).

# Наследование: класс Dog ЯВЛЯЕтся Animal
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name} издает звук")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} лает: Гав!")

# Использование
dog = Dog("Шарик")
dog.speak()  # Шарик лает: Гав!

Что такое композиция?

Композиция — это когда класс содержит другие объекты как свойства через отношение "имеет" (has-a relationship). Вместо наследования мы используем объекты как части.

# Композиция: класс Dog ИМЕЕТ Bark (поведение)
class Bark:
    def make_sound(self, name):
        print(f"{name} лает: Гав!")

class Dog:
    def __init__(self, name):
        self.name = name
        self.barker = Bark()  # ← Композиция: используем объект
    
    def speak(self):
        self.barker.make_sound(self.name)

# Использование
dog = Dog("Шарик")
dog.speak()  # Шарик лает: Гав!

Основные различия

Проблема наследования: иерархия становится хрупкой

# Напишем иерархию наследования
class Animal:
    def eat(self):
        print("Ем")

class Bird(Animal):
    def fly(self):
        print("Летаю")

class Penguin(Bird):  # Пингвин является Bird
    pass

# ПРОБЛЕМА: Пингвин не летает! Но наследует методу fly()
penguin = Penguin()
penguin.fly()  # "Летаю" ← Это неправильно!

# Нужно переопределять методы, чтобы выбросить исключение
class Penguin(Bird):
    def fly(self):
        raise NotImplementedError("Пингвины не летают")

Решение: композиция вместо наследования

# Вместо иерархии, используем композицию
class EatingBehavior:
    def eat(self):
        print("Ем")

class FlyingBehavior:
    def fly(self):
        print("Летаю")

class NonFlyingBehavior:
    def fly(self):
        raise NotImplementedError("Это животное не летает")

# Теперь мы комбинируем поведения
class Eagle:
    def __init__(self):
        self.eating = EatingBehavior()
        self.flying = FlyingBehavior()
    
    def fly(self):
        self.flying.fly()

class Penguin:
    def __init__(self):
        self.eating = EatingBehavior()
        self.flying = NonFlyingBehavior()  # ← Выбираем нужное поведение
    
    def fly(self):
        self.flying.fly()

# Использование
eagle = Eagle()
eagle.fly()  # "Летаю"

penguin = Penguin()
penguin.fly()  # NotImplementedError

Практический пример: система уведомлений

Наследование (ПЛОХО)

class Notifier:
    def send(self, message):
        raise NotImplementedError

class EmailNotifier(Notifier):
    def send(self, message):
        print(f"Email: {message}")

class SMSNotifier(Notifier):
    def send(self, message):
        print(f"SMS: {message}")

class PushNotifier(Notifier):
    def send(self, message):
        print(f"Push: {message}")

# ПРОБЛЕМА: что если нужны все три? Наследование не подходит
# Нельзя наследовать от трёх классов одновременно (проблема ромба)

Композиция (ХОРОШО)

class Notifier:
    def send(self, message):
        raise NotImplementedError

class EmailNotifier(Notifier):
    def send(self, message):
        print(f"Email: {message}")

class SMSNotifier(Notifier):
    def send(self, message):
        print(f"SMS: {message}")

class PushNotifier(Notifier):
    def send(self, message):
        print(f"Push: {message}")

# Композиция: комбинируем несколько уведомителей
class NotificationService:
    def __init__(self, notifiers: list[Notifier]):
        self.notifiers = notifiers  # ← Список уведомителей
    
    def notify(self, message: str):
        for notifier in self.notifiers:
            notifier.send(message)

# Использование
service = NotificationService([
    EmailNotifier(),
    SMSNotifier(),
    PushNotifier(),
])

service.notify("Привет!")  # Отправляет через все каналы

Практический пример: система оплаты

Наследование (НЕПРАВИЛЬНО)

# Это создаст огромное дерево наследования!
class Payment:
    def process(self):
        raise NotImplementedError

class CreditCardPayment(Payment):  # Credit Card
    def process(self):
        print("Обработка Credit Card")

class PayPalPayment(Payment):  # PayPal
    def process(self):
        print("Обработка PayPal")

class CreditCardPayPalPayment(Payment):  # Credit Card + PayPal?
    # Невозможно наследовать от двух!
    pass

Композиция (ПРАВИЛЬНО)

from abc import ABC, abstractmethod

class PaymentMethod(ABC):
    @abstractmethod
    def charge(self, amount: float):
        pass

class CreditCard(PaymentMethod):
    def charge(self, amount: float):
        print(f"Списание {amount} с credit card")

class PayPal(PaymentMethod):
    def charge(self, amount: float):
        print(f"Списание {amount} через PayPal")

class ApplePay(PaymentMethod):
    def charge(self, amount: float):
        print(f"Списание {amount} через Apple Pay")

# Композиция: Order содержит методы оплаты
class Order:
    def __init__(self, payment_methods: list[PaymentMethod]):
        self.payment_methods = payment_methods
    
    def checkout(self, total: float):
        for method in self.payment_methods:
            method.charge(total)  # Пытаемся с каждого метода

# Использование: поддерживаем несколько методов
order = Order([
    CreditCard(),
    PayPal(),
])
order.checkout(100.0)  # Обработает оба метода

Когда всё-таки использовать наследование?

Наследование имеет смысл только когда:

• Есть явное отношение "является" (is-a)
• Подклассы добавляют специализированное поведение
• Иерархия не глубокая (2-3 уровня максимум)

# Правильное использование наследования
class Vehicle:
    def __init__(self, brand: str):
        self.brand = brand
    
    def start(self):
        print("Двигатель запущен")

class Car(Vehicle):
    """Car ЯВЛЯЕтся Vehicle — правильное отношение"""
    def drive(self):
        print("Едем")

class ElectricCar(Car):
    """ElectricCar ЯВЛЯЕтся Car — специализированное поведение"""
    def charge(self):
        print("Зарядка батареи")

Пример: Strategy Pattern через композицию

from abc import ABC, abstractmethod

# Абстрактный класс для стратегии сортировки
class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data: list):
        pass

class QuickSort(SortStrategy):
    def sort(self, data: list):
        # Реализация QuickSort
        return sorted(data)

class MergeSort(SortStrategy):
    def sort(self, data: list):
        # Реализация MergeSort
        return sorted(data)

# Композиция: класс использует стратегию
class Sorter:
    def __init__(self, strategy: SortStrategy):
        self.strategy = strategy  # ← Инъекция зависимости
    
    def sort_data(self, data: list):
        return self.strategy.sort(data)

# Использование
quick_sorter = Sorter(QuickSort())
data = [3, 1, 2]
print(quick_sorter.sort_data(data))  # [1, 2, 3]

# Легко менять стратегию
merge_sorter = Sorter(MergeSort())
print(merge_sorter.sort_data(data))  # [1, 2, 3]

Тестирование: композиция лучше

# С наследованием сложнее мокировать
class Calculator:
    def add(self, a, b):
        return a + b

class AdvancedCalculator(Calculator):  # Наследование
    def calculate_total(self):
        return self.add(1, 2)  # Нельзя легко мокировать

# С композицией легко подменять
class Calculator:
    def add(self, a, b):
        return a + b

class AdvancedCalculator:
    def __init__(self, calculator: Calculator):  # Композиция
        self.calculator = calculator
    
    def calculate_total(self):
        return self.calculator.add(1, 2)  # Легко подменять

# В тестах
class MockCalculator:
    def add(self, a, b):
        return 999

calc = AdvancedCalculator(MockCalculator())  # Просто подменяем
print(calc.calculate_total())  # 999

Принцип SOLID: Liskov Substitution Principle

# НАРУШЕНИЕ LSP: Penguin не может заменить Bird
class Bird:
    def fly(self):
        pass

class Penguin(Bird):
    def fly(self):  # ← Это нарушает контракт
        raise NotImplementedError

# ПРАВИЛЬНО: используем композицию
class Bird:
    def __init__(self, flying_behavior):
        self.flying = flying_behavior
    
    def fly(self):
        self.flying.fly()  # Это всегда работает

Итоговый вывод

• Наследование хорошо для ясной иерархии "является"
• Композиция лучше для гибкости и избегания хрупких иерархий
• Современный подход в Python: композиция + инъекция зависимостей
• Композиция позволяет менять поведение во время выполнения
• Композиция облегчает тестирование (мокирование)
• Правило: "Предпочитай композицию наследованию" (Composition over Inheritance)