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

# Эволюция интерфейсов в Java: от Java 5 до Java 21

Краткая таблица

1. Java 5-7: Классические интерфейсы

// Только методы (абстрактные)
public interface Animal {
    void makeSound(); // Абстрактный метод
    String getName(); // Абстрактный метод
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }

    @Override
    public String getName() {
        return "Dog";
    }
}

Характеристики:

• Только публичные абстрактные методы
• Нет реализации в интерфейсе
• Класс должен реализовать ВСЕ методы
• Нет переменных (или только константы public static final)
• Нет конструкторов

Проблема:

// Если добавить новый метод в интерфейс...
public interface Animal {
    void makeSound();
    String getName();
    void sleep(); // ❌ Все реализации нужно обновить!
}

2. Java 8: Default Methods — революция!

Проблема, которую решили: Добавлять методы в интерфейсы без реализации по всему коду.

// Default метод имеет реализацию
public interface Animal {
    void makeSound(); // Абстрактный
    
    // Default метод (реализация есть)
    default void sleep() {
        System.out.println("Zzzzz...");
    }
    
    // Static метод
    static void info() {
        System.out.println("Это интерфейс Animal");
    }
}

// Реализация может не переопределять default методы
public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
    // sleep() — унаследовал дефолтную реализацию
}

// Использование
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Bark
        dog.sleep();      // Zzzzz... (default метод)
        Animal.info();    // Это интерфейс Animal (static метод)
    }
}

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

• ✅ Можно добавлять методы без обновления всех реализаций
• ✅ Обратная совместимость
• ✅ Code reuse через интерфейсы
• ✅ Более гибкие контракты

Конфликты при множественном наследовании:

public interface A {
    default void method() {
        System.out.println("A");
    }
}

public interface B {
    default void method() {
        System.out.println("B");
    }
}

// ❌ Конфликт! Какой метод выбрать?
public class C implements A, B {
    @Override
    public void method() {
        // Нужно явно разрешить конфликт
        A.super.method(); // Вызовем A
        B.super.method(); // или B
    }
}

3. Java 9: Private Methods

Проблема: Default методы начали дублировать код.

// Java 8 — нельзя скрыть от наследника
public interface PaymentProcessor {
    default void processPayment(double amount) {
        validatePayment(amount); // ❌ Публичный, видно в наследнике
        executePayment(amount);
    }
    
    default void validatePayment(double amount) {
        if (amount <= 0) throw new IllegalArgumentException();
    }
    
    default void executePayment(double amount) {
        System.out.println("Executing: " + amount);
    }
}

// Java 9+ — private методы
public interface PaymentProcessor {
    default void processPayment(double amount) {
        validatePayment(amount); // Private, скрыт
        executePayment(amount);
    }
    
    private void validatePayment(double amount) {
        if (amount <= 0) throw new IllegalArgumentException();
    }
    
    private void executePayment(double amount) {
        System.out.println("Executing: " + amount);
    }
    
    // Также есть private static методы
    private static void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

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

• ✅ Общий код для default методов
• ✅ Инкапсуляция вспомогательной логики
• ✅ Чёткий контракт интерфейса

4. Java 17: Sealed Interfaces

Проблема: Хотим контролировать, кто может реализовать интерфейс.

// Только указанные классы могут реализовать интерфейс
public sealed interface Transport
    permits Car, Bike, Truck {
    void drive();
}

public class Car implements Transport {
    @Override
    public void drive() {
        System.out.println("Driving car");
    }
}

public class Bike implements Transport {
    @Override
    public void drive() {
        System.out.println("Riding bike");
    }
}

// ❌ Ошибка компиляции!
// public class Plane implements Transport { }

// Использование с Pattern Matching
public void handleTransport(Transport transport) {
    if (transport instanceof Car car) {
        car.drive(); // car уже типизирован
    } else if (transport instanceof Bike bike) {
        bike.drive();
    }
}

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

• ✅ Контроль над иерархией типов
• ✅ Pattern matching без instanceof кастов
• ✅ Предсказуемость кода
• ✅ Оптимизация JVM

5. Практический пример эволюции

// ============ JAVA 5 ============
public interface Logger {
    void log(String message);
}

public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println(message);
    }
}

// ============ JAVA 8 ============
public interface Logger {
    void log(String message);
    
    // Теперь можем добавить без обновления ConsoleLogger
    default void info(String message) {
        log("[INFO] " + message);
    }
    
    default void error(String message) {
        log("[ERROR] " + message);
    }
    
    static Logger createConsoleLogger() {
        return message -> System.out.println(message);
    }
}

// ============ JAVA 9 ============
public interface Logger {
    void log(String message);
    
    default void info(String message) {
        format(message); // Private helper
        log("[INFO] " + message);
    }
    
    // Скрытая вспомогательная логика
    private void format(String message) {
        // Валидация, форматирование...
    }
    
    private static void audit(String msg) {
        // Логирование для аудита
    }
}

// ============ JAVA 17 ============
public sealed interface Logger
    permits ConsoleLogger, FileLogger, DatabaseLogger {
    void log(String message);
    
    default void info(String message) {
        log("[INFO] " + message);
    }
    
    private void validateMessage(String message) {
        if (message == null || message.isEmpty()) {
            throw new IllegalArgumentException();
        }
    }
}

public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println(message);
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        Logger logger = new ConsoleLogger();
        logger.info("Application started"); // [INFO] Application started
    }
}

6. Сравнение возможностей

7. Лучшие практики

Когда использовать Default методы

// ✅ Хорошо — общее поведение
public interface Repository<T> {
    T findById(Long id);
    
    default List<T> findAll() {
        return findById(0) != null ? Collections.emptyList() : new ArrayList<>();
    }
}

// ❌ Плохо — слишком много реализации
public interface ComplexService {
    default void complexLogic() {
        // 100 строк кода...
    }
}

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

// ✅ Правильно — контролируемая иерархия
public sealed interface PaymentMethod
    permits CreditCard, Wallet, Bank {
    void pay(double amount);
}

// ❌ Не нужен — если возможны расширения
public sealed interface Plugin
    permits A, B, C {
    void execute();
}
// Лучше просто interface Plugin без sealed

8. Миграция между версиями

// Старый код (Java 7)
public interface DataSource {
    Connection getConnection();
}

// Разработка на Java 8
public interface DataSource {
    Connection getConnection();
    
    // Добавили default — существующий код не сломается
    default void close() throws Exception {
        // стандартная реализация
    }
}

// Современный подход (Java 17+)
public sealed interface DataSource
    permits PostgresDataSource, MySQLDataSource {
    Connection getConnection();
    
    private default void validateConnection(Connection conn) {
        if (conn == null) throw new IllegalStateException();
    }
}

Заключение

Java 5-7: Интерфейсы — только контракт без реализации Java 8: Default методы — реализация внутри интерфейса Java 9: Private методы — инкапсуляция Java 17: Sealed интерфейсы — контроль над реализациями Java 21: Pattern matching — удобнее работать с sealed типами

Эволюция интерфейсов отражает общий тренд Java: от простых контрактов к более выразительным, безопасным и удобным в использовании конструкциям.