Чем композиция лучше наследования?

Композиция vs Наследование в Python

Краткий ответ

Композиция гибче, чем наследование, потому что позволяет комбинировать поведение без жёстких иерархических связей. Это ключевой принцип в ООП: "Favoring composition over inheritance".

Проблемы наследования

1. Хрупкая иерархия

Жёсткая иерархия создаёт проблемы при изменениях:

# Плохо: жёсткое наследование
class Animal:
    def move(self):
        pass

class Dog(Animal):
    def move(self):
        return "Бежит"

class Bird(Animal):
    def move(self):
        return "Летит"

class Penguin(Bird):  # Пингвин наследует от птицы
    def move(self):
        return "Плывёт"  # Но переопределяет поведение

# Проблема: Penguin — это Bird, но не летает
# Наследование подразумевает "is-a", но Penguin не совсем Bird

2. Diamond Problem (проблема ромба)

class A:
    def method(self):
        return "A"

class B(A):
    pass

class C(A):
    pass

class D(B, C):  # Множественное наследование
    pass

d = D()
# Какой метод вызовется? MRO (Method Resolution Order) поможет,
# но это сложность
print(D.mro())

3. Плотная связанность

Дочерний класс зависит от внутренней реализации родителя:

class Logger:
    def log(self, msg):
        print(f"[LOG] {msg}")

class MyService(Logger):  # Наследует логирование
    def process(self):
        self.log("Processing")  # Зависит от Logger

# Если Logger изменится, MyService сломается

Решение: Композиция

1. Композиция через внедрение зависимостей

# Хорошо: композиция вместо наследования
class Logger:
    def log(self, msg: str) -> None:
        print(f"[LOG] {msg}")

class MyService:
    def __init__(self, logger: Logger):
        self.logger = logger  # Внедряем логгер
    
    def process(self) -> None:
        self.logger.log("Processing")

# MyService не зависит от Logger
# Можем подменить Logger на другую реализацию
logger = Logger()
service = MyService(logger)

2. Гибкое комбинирование поведения

# Вместо иерархии наследования
class Mover:
    def move(self) -> str:
        raise NotImplementedError

class Runner(Mover):
    def move(self) -> str:
        return "Бежит"

class Swimmer(Mover):
    def move(self) -> str:
        return "Плывёт"

# Композиция: комбинируем поведение
class Animal:
    def __init__(self, mover: Mover, name: str):
        self.mover = mover
        self.name = name
    
    def move(self) -> str:
        return f"{self.name} {self.mover.move()}"

dog = Animal(Runner(), "Собака")
print(dog.move())  # Собака Бежит

penguin = Animal(Swimmer(), "Пингвин")
print(penguin.move())  # Пингвин Плывёт

# Легко переключаться между поведением
amphibian = Animal(Runner(), "Жаба")
amphibian.mover = Swimmer()
print(amphibian.move())  # Жаба Плывёт

3. Множественная композиция

class Flyable:
    def fly(self) -> str:
        return "Летит в небе"

class Swimmable:
    def swim(self) -> str:
        return "Плывёт в воде"

class Walkable:
    def walk(self) -> str:
        return "Ходит по земле"

# Bird может летать и ходить
class Bird:
    def __init__(self):
        self.flyable = Flyable()
        self.walkable = Walkable()
    
    def move(self) -> list[str]:
        return [self.flyable.fly(), self.walkable.walk()]

# Duck может летать, ходить И плавать
class Duck:
    def __init__(self):
        self.flyable = Flyable()
        self.swimmable = Swimmable()
        self.walkable = Walkable()
    
    def move(self) -> list[str]:
        return [
            self.flyable.fly(),
            self.swimmable.swim(),
            self.walkable.walk()
        ]

duck = Duck()
print(duck.move())  # Все возможности без конфликтов

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

Наследование подходит для:

1. Специализация одного концепта — когда есть ясная иерархия

   class PaymentMethod:
       def pay(self, amount):
           raise NotImplementedError
   
   class CreditCard(PaymentMethod):
       def pay(self, amount):
           return f"Платёж {amount} с карты"
   

2. Полиморфизм через интерфейсы

   from abc import ABC, abstractmethod
   
   class DataStorage(ABC):
       @abstractmethod
       def save(self, data):
           pass
   
   class Database(DataStorage):
       def save(self, data):
           # Реализация
           pass
   

3. Переопределение с расширением функциональности

   class BaseList(list):
       def push(self, item):
           self.append(item)
           return self
   
   my_list = BaseList([1, 2, 3])
   my_list.push(4)  # Удобство
   

Таблица сравнения

Золотое правило

Используй композицию по умолчанию. Наследование берись только когда наследование — это действительно правильная модель проблемы (например, интерфейсы в ABC или специализация сущности).

# Правило большого пальца:
if relationship == "is-a" and hierarchy_is_simple:
    use_inheritance()
else:
    use_composition()  # В 80% случаев

Вывод: Композиция выигрывает в реальных проектах благодаря гибкости, простоте тестирования и отсутствию сложностей с иерархией. Наследование — это инструмент для специфических случаев, не универсальное решение.