В чем разница между работой с абстрактными классами в разных версиях Java?

Эволюция работы с абстрактными классами в разных версиях Java

Профессиональный Java разработчик должен понимать, как изменялась работа с абстрактными классами, так как эти изменения повлияли на проектирование и выбор между абстрактными классами и интерфейсами.

Java 5: Базовая функциональность

До Java 8 абстрактные классы имели четкую роль - определять общее состояние и поведение:

// Java 5
public abstract class Animal {
    // Состояние (только в абстрактных классах)
    protected String name;
    protected int age;
    
    // Конструктор (только в абстрактных классах)
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Конкретные методы с реализацией
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
    
    // Абстрактные методы (без реализации)
    public abstract void makeSound();
    public abstract void eat();
}

// Интерфейсы были чистыми контрактами
public interface Predator {
    void hunt();  // Только сигнатуры методов
}

// Наследование и реализация
public class Dog extends Animal implements Predator {
    public Dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " barks: Woof!");
    }
    
    @Override
    public void eat() {
        System.out.println(name + " eats meat");
    }
    
    @Override
    public void hunt() {
        System.out.println(name + " is hunting");
    }
}

Java 8: Появление Default Methods в интерфейсах

Java 8 размыла границу между абстрактными классами и интерфейсами:

// Java 8: интерфейсы могут иметь методы с реализацией!
public interface Predator {
    // Абстрактный метод
    void hunt();
    
    // Default метод (с реализацией)
    default void rest() {
        System.out.println("Predator is resting");
    }
}

// Абстрактные классы все еще более мощные
public abstract class Animal {
    protected String name;      // ✅ Состояние (в интерфейсах нет!)
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;         // ✅ Инициализация (в интерфейсах нет!)
    }
    
    // Методы с логикой
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
    
    public abstract void makeSound();
}

// Теперь интерфейсы могут содержать логику
public class Dog extends Animal implements Predator {
    public Dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " barks: Woof!");
    }
    
    @Override
    public void hunt() {
        System.out.println(name + " hunts prey");
    }
    
    // rest() наследуется из интерфейса Predator (default реализация)
}

Java 8: Static методы в интерфейсах

// Java 8
public interface Comparator<T> {
    // Абстрактный метод
    int compare(T o1, T o2);
    
    // Default метод
    default Comparator<T> reversed() {
        return (o1, o2) -> compare(o2, o1);
    }
    
    // Static метод (новое в Java 8)
    static <T> Comparator<T> comparingByName(Function<T, String> function) {
        return (o1, o2) -> function.apply(o1).compareTo(function.apply(o2));
    }
}

// Абстрактные классы также могут иметь static методы
public abstract class Animal {
    public static Animal create(String type) {
        switch(type) {
            case "dog": return new Dog("Rex", 5);
            case "cat": return new Cat("Whiskers", 3);
            default: throw new IllegalArgumentException();
        }
    }
}

Java 9: Private методы в интерфейсах

Java 9 позволила использовать private методы в интерфейсах для переиспользования кода:

// Java 9
public interface Predator {
    // Абстрактный метод
    void hunt();
    
    // Default метод
    default void huntAndRest() {
        hunt();
        rest();  // Использует private метод
    }
    
    // Private метод (новое в Java 9)
    private void rest() {
        System.out.println("Taking a break after hunting");
    }
}

// Абстрактные классы всегда имели private методы
public abstract class Animal {
    public void activity() {
        prepare();    // Использует private метод
        doAction();
        cleanup();    // Использует private метод
    }
    
    private void prepare() {
        System.out.println("Preparing...");
    }
    
    private void cleanup() {
        System.out.println("Cleaning up...");
    }
    
    protected abstract void doAction();
}

Java 11: Sealed классы (Preview)

// Java 15+ (Sealed classes)
// Контроль над тем, какие классы могут наследовать

public abstract sealed class Animal permits Dog, Cat, Bird {
    protected String name;
    protected int age;
    
    public abstract void makeSound();
}

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

public sealed class Cat extends Animal permits PersianCat, SiameseCat {
    // Cat сам может быть sealed
}

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

// Интерфейсы также могут быть sealed
public sealed interface Shape permits Circle, Rectangle {
    double getArea();
}

Сравнение возможностей по версиям

Практическое влияние на архитектуру

// Java 5-7: Четкое разделение
// Абстрактные классы для состояния, интерфейсы для контрактов

// Java 8-14: Интерфейсы становятся почти как абстрактные классы
// Выбор становится сложнее
public interface DataProcessor {
    void process();
    
    // Можно добавить логику через default
    default void processAndLog() {
        process();
        log();
    }
    
    // Нельзя добавить состояние
    // private void log() { ... }
}

// Java 15+: Sealed классы уточняют иерархию
public sealed abstract class DataProcessor permits JsonProcessor, XmlProcessor {
    protected String data;  // Состояние
    
    public abstract void process();
    
    protected void log() {  // Protected методы
        System.out.println("Processing: " + data);
    }
}

public final class JsonProcessor extends DataProcessor {
    @Override
    public void process() {
        // JSON обработка
    }
}

Рекомендации по выбору

Используй абстрактный класс когда:

• Нужно состояние (поля)
• Нужны конструкторы для инициализации
• Нужны protected/private методы
• Нужен контроль доступа к членам
• Иерархия классов строго определена (Java 15+: sealed)

Используй интерфейс когда:

• Определяешь поведение (контракт)
• Нужна множественная реализация
• Нет общего состояния
• Описываешь capability (может-ли объект)

// Хорошие примеры
public abstract class DatabaseConnection {
    protected String url;
    protected Connection connection;
    
    public DatabaseConnection(String url) {
        this.url = url;
    }
}

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

Вывод

Java эволюционировал, размывая границы между абстрактными классами и интерфейсами:

• Java 5-7: Четкое разделение ролей
• Java 8: Интерфейсы получили default методы (приблизились к абстрактным классам)
• Java 9: Интерфейсы получили private методы (еще ближе)
• Java 15+: Sealed классы уточняют иерархию

Несмотря на сходство, абстрактные классы остаются более мощными благодаря состоянию и конструкторам.