От чего наследоваться кроме интерфейса, чтобы реализовать полиморфизм?

От чего наследоваться кроме интерфейса, чтобы реализовать полиморфизм?

В Java есть несколько способов реализовать полиморфизм, кроме интерфейсов. Давай разберём каждый.

1. Наследование от абстрактного класса

Абстрактный класс — это самый гибкий способ реализовать полиморфизм:

public abstract class Animal {
    public abstract void makeSound();
    
    public void sleep() {
        System.out.println("Zzz...");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

Отличие от интерфейса:

• Может иметь конкретные методы (с реализацией) — sleep()
• Может иметь состояние (переменные) — protected String name
• Конструкторы для инициализации
• Модификаторы доступа: private, protected, public

Когда использовать:

• ✅ Есть общее состояние между классами
• ✅ Есть реализация некоторых методов
• ✅ Нужны protected или private методы

2. Наследование от конкретного класса

Можно наследоваться и от обычного класса, хотя это менее гибко:

public class Vehicle {
    protected String model;
    
    public void start() {
        System.out.println("Starting...");
    }
}

public class Car extends Vehicle {
    public void honk() {
        System.out.println("Beep!");
    }
}

public class Truck extends Vehicle {
    public void loadCargo() {
        System.out.println("Loading...");
    }
}

Полиморфизм работает так же:

List<Vehicle> vehicles = new ArrayList<>();
vehicles.add(new Car());
vehicles.add(new Truck());

for (Vehicle v : vehicles) {
    v.start(); // вызывает нужный метод в зависимости от типа
}

Когда использовать:

• ✅ Есть иерархия классов (Animal → Mammal → Dog)
• ✅ Хочется переиспользовать code
• ❌ Нужна гибкость — наследование более жёсткое, чем интерфейсы

3. Интерфейсы + наследование (лучший подход)

В современной Java рекомендуется комбинировать интерфейсы и наследование:

public interface Animal {
    void makeSound();
}

public abstract class Mammal implements Animal {
    protected String species;
    
    public void sleep() {
        System.out.println("Mammal is sleeping");
    }
}

public class Dog extends Mammal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

Теперь у нас есть:

• Интерфейс — контракт поведения
• Абстрактный класс — переиспользуемая логика
• Наследование — иерархия классов

4. Полиморфизм через generics (type parameters)

В Java 5+ есть параметризованные типы для полиморфизма без наследования:

public interface Repository<T> {
    T findById(Long id);
    void save(T entity);
}

public class UserRepository implements Repository<User> {
    @Override
    public User findById(Long id) {
        return new User();
    }
    
    @Override
    public void save(User entity) {}
}

public class OrderRepository implements Repository<Order> {
    @Override
    public Order findById(Long id) {
        return new Order();
    }
    
    @Override
    public void save(Order entity) {}
}

Возможны ограничения типов:

public <T extends Number> void processNumber(T number) {
    System.out.println(number.doubleValue());
}

5. Полиморфизм через композицию

Это не наследование, но тоже полиморфизм — Composition over Inheritance:

public class PaymentProcessor {
    private PaymentGateway gateway; // интерфейс!
    
    public PaymentProcessor(PaymentGateway gateway) {
        this.gateway = gateway;
    }
    
    public void process(BigDecimal amount) {
        gateway.charge(amount); // может быть Stripe, PayPal, местный платёж
    }
}

public interface PaymentGateway {
    void charge(BigDecimal amount);
}

public class StripeGateway implements PaymentGateway {
    @Override
    public void charge(BigDecimal amount) {
        System.out.println("Charging via Stripe: " + amount);
    }
}

Это более гибко, чем наследование, потому что:

• Можешь менять реализацию в runtime
• Нет проблем с множественным наследованием
• Легче тестировать (mock'ировать)

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

Рекомендация

Используй этот порядок:

1. Интерфейс для определения контракта
2. Абстрактный класс для переиспользуемой логики
3. Конкретные классы для реализации
4. Композиция вместо наследования, если возможно

public interface Logger {
    void log(String message);
}

public abstract class BaseLogger implements Logger {
    protected String prefix = "[LOG]";
    
    protected void addTimestamp(String msg) {
        System.out.println(prefix + " " + LocalDateTime.now() + " " + msg);
    }
}

public class ConsoleLogger extends BaseLogger {
    @Override
    public void log(String message) {
        addTimestamp(message);
    }
}

public class FileLogger extends BaseLogger {
    @Override
    public void log(String message) {
        addTimestamp(message);
        // write to file
    }
}

Этот паттерн даёт полиморфизм, переиспользование кода и гибкость одновременно.