Какие знаешь альтернативы наследованию?

Альтернативы наследованию в Java

Наследование часто переоценивается и может привести к хрупкому коду. В современной разработке существуют более гибкие подходы для переиспользования кода и построения иерархий типов.

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

// ❌ Проблема: хрупкая иерархия
class Animal {
    void eat() { /* ... */ }
}

class Bird extends Animal {
    void fly() { /* ... */ }
}

class Penguin extends Bird {
    // Пингвин не летает, но наследует fly()!
}

1. Композиция (Composition over Inheritance)

Самая популярная альтернатива. Вместо наследования используем объекты как члены класса:

// ✅ Хорошо — композиция
interface Engine {
    void start();
}

class ElectricEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Electric engine started");
    }
}

class Car {
    private final Engine engine;
    
    public Car(Engine engine) {
        this.engine = engine;
    }
    
    public void drive() {
        engine.start();
        System.out.println("Car is driving");
    }
}

// Использование
Car car = new Car(new ElectricEngine());
car.drive();

Преимущества:

• Гибкость: легко заменить компонент
• Слабая связанность: компоненты независимы
• Тестируемость: можно использовать моки
• Нет проблемы с хрупкостью базовых классов

2. Интерфейсы (Interfaces)

Интерфейсы определяют контракт поведения без наследования реализации:

interface Transport {
    void move();
    void stop();
}

class Car implements Transport {
    @Override
    public void move() { System.out.println("Car moves"); }
    
    @Override
    public void stop() { System.out.println("Car stops"); }
}

class Bicycle implements Transport {
    @Override
    public void move() { System.out.println("Bicycle moves"); }
    
    @Override
    public void stop() { System.out.println("Bicycle stops"); }
}

// Используем интерфейс, не заботясь о конкретной реализации
Transport[] vehicles = { new Car(), new Bicycle() };
for (Transport v : vehicles) {
    v.move();
}

Преимущества:

• Множественное наследование интерфейсов
• Чистый контракт поведения
• Слабая связанность

3. Делегирование (Delegation)

Явная передача ответственности другому объекту:

// ❌ Наследование
class ExtendedList<T> extends ArrayList<T> {
    public void printSize() {
        System.out.println("Size: " + size());
    }
}

// ✅ Делегирование
class ListWrapper<T> {
    private final List<T> delegate;
    
    public ListWrapper(List<T> delegate) {
        this.delegate = delegate;
    }
    
    public void add(T item) {
        delegate.add(item);
    }
    
    public void printSize() {
        System.out.println("Size: " + delegate.size());
    }
}

Преимущества:

• Явное показывает зависимости
• Легче отследить вызовы методов
• Не нарушает инкапсуляцию базового класса

4. Миксины и Default Methods (Java 8+)

Default методы в интерфейсах позволяют добавлять функциональность без наследования:

interface Flyable {
    default void fly() {
        System.out.println("Flying...");
    }
}

interface Swimmable {
    default void swim() {
        System.out.println("Swimming...");
    }
}

class Duck implements Flyable, Swimmable {
    // Наследует fly() и swim() от интерфейсов
    // Но может переопределить если нужно
    
    @Override
    public void swim() {
        System.out.println("Duck swims");
    }
}

Преимущества:

• Множественное наследование поведения
• Нет хрупкости иерархии
• Чистый код

5. Стратегия (Strategy Pattern)

Инкапсулирует различные алгоритмы в отдельные классы:

interface PaymentStrategy {
    void pay(double amount);
}

class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " with credit card");
    }
}

class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " with PayPal");
    }
}

class ShoppingCart {
    private PaymentStrategy strategy;
    
    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void checkout(double total) {
        strategy.pay(total);
    }
}

// Использование
ShoppingCart cart = new ShoppingCart();
cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(100);

Когда использовать: когда нужна гибкая смена поведения во время выполнения

6. Декоратор (Decorator Pattern)

Динамически добавляет функциональность к объекту:

interface Coffee {
    double getCost();
    String getDescription();
}

class SimpleCoffee implements Coffee {
    @Override
    public double getCost() { return 10; }
    
    @Override
    public String getDescription() { return "Simple coffee"; }
}

class MilkDecorator implements Coffee {
    private final Coffee coffee;
    
    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
    
    @Override
    public double getCost() {
        return coffee.getCost() + 5;
    }
    
    @Override
    public String getDescription() {
        return coffee.getDescription() + ", with milk";
    }
}

// Использование
Coffee coffee = new MilkDecorator(new SimpleCoffee());
System.out.println(coffee.getCost()); // 15
System.out.println(coffee.getDescription()); // Simple coffee, with milk

7. Traits и Mixins

В Java реализуется через интерфейсы с default методами (как выше). В Scala есть встроенная поддержка traits.

Сравнительная таблица

Правило SOLID

• Single Responsibility — класс отвечает за одно
• Open/Closed — открыт для расширения, закрыт для модификации
• Liskov Substitution — подтипы заменяемы
• Interface Segregation — специфичные интерфейсы
• Dependency Inversion — зависимости от абстракций

Все альтернативы наследованию помогают следовать этим принципам.