Какая реализация появилась в интерфейсах Java?

Методы по умолчанию и статические методы в интерфейсах Java

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

Default Methods (Java 8): default методы

Основная реализация в интерфейсах — это методы с ключевым словом default:

public interface PaymentProcessor {
    // Абстрактный метод (как раньше)
    void processPayment(Double amount);
    
    // ✅ Default метод — имеет реализацию
    default void logTransaction(String details) {
        System.out.println("Transaction: " + details);
    }
    
    default void validateAmount(Double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
    }
}

// Реализующий класс НЕ обязан переопределять default методы
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(Double amount) {
        validateAmount(amount);  // может использовать default метод
        // процесс платежа
    }
    
    // logTransaction() унаследуется от интерфейса
}

// Использование
public class PaymentDemo {
    public static void main(String[] args) {
        PaymentProcessor processor = new CreditCardProcessor();
        
        // Вызов переопределённого метода
        processor.processPayment(100.0);
        
        // Вызов default метода (не переопределён)
        processor.logTransaction("Payment processed");
        // Вывод: "Transaction: Payment processed"
    }
}

Зачем нужны default методы?

1. Обратная совместимость (Backward Compatibility)

При эволюции интерфейса можно добавить новый метод без поломки существующего кода:

// Старая версия интерфейса
public interface DataStore {
    List<User> getAllUsers();
    User getUserById(Long id);
}

// Много классов имплементируют этот интерфейс:
public class DatabaseStore implements DataStore { ... }
public class CacheStore implements DataStore { ... }
public class FileStore implements DataStore { ... }

// ПРОБЛЕМА: добавить новый метод?
// ❌ СТАРЫЙ СПОСОБ:
public interface DataStore {
    List<User> getAllUsers();
    User getUserById(Long id);
    
    // Добавляем новый метод
    List<User> getUsersByAge(int age);
    // ВСЕ 100 классов-реализаторов теперь не компилируются!
}

// ✅ С default методом:
public interface DataStore {
    List<User> getAllUsers();
    User getUserById(Long id);
    
    // Новый метод с реализацией по умолчанию
    default List<User> getUsersByAge(int age) {
        return getAllUsers().stream()
            .filter(u -> u.getAge() == age)
            .collect(Collectors.toList());
    }
}
// Все реализации продолжают работать без изменений!

2. Избегание создания утилитарных классов

// ❌ СТАРЫЙ СПОСОБ: утилитарный класс
public interface Logger {
    void log(String message);
}

public class LoggerUtils {
    public static void logError(Logger logger, String message) {
        logger.log("ERROR: " + message);
    }
    
    public static void logWarning(Logger logger, String message) {
        logger.log("WARN: " + message);
    }
}

// Использование
Logger logger = new ConsoleLogger();
LoggerUtils.logError(logger, "Something went wrong");

// ✅ С default методом:
public interface Logger {
    void log(String message);
    
    default void logError(String message) {
        log("ERROR: " + message);
    }
    
    default void logWarning(String message) {
        log("WARN: " + message);
    }
}

// Использование
Logger logger = new ConsoleLogger();
logger.logError("Something went wrong");  // Чище и понятнее

Static Methods в интерфейсах (Java 8)

Помимо default методов, интерфейсы могут содержать static методы:

public interface PaymentFactory {
    // Static метод
    static PaymentProcessor createProcessor(String type) {
        return switch (type) {
            case "CREDIT_CARD" -> new CreditCardProcessor();
            case "PAYPAL" -> new PayPalProcessor();
            case "BANK_TRANSFER" -> new BankTransferProcessor();
            default -> throw new IllegalArgumentException("Unknown type: " + type);
        };
    }
    
    // Default метод
    default void validateProcessor() {
        System.out.println("Validation in progress...");
    }
    
    void process(Double amount);
}

// Использование
public class PaymentService {
    public void pay(String processorType, Double amount) {
        PaymentProcessor processor = PaymentFactory.createProcessor(processorType);
        processor.process(amount);
    }
}

Важно: static методы в интерфейсах НЕ наследуются реализующими классами:

public class MyProcessor implements PaymentFactory {
    @Override
    public void process(Double amount) {
        // ...
    }
}

public class Main {
    public static void main(String[] args) {
        // ✅ Вызов через интерфейс работает
        PaymentProcessor p1 = PaymentFactory.createProcessor("CREDIT_CARD");
        
        // ❌ Вызов через реализующий класс НЕ работает
        // MyProcessor.createProcessor("CREDIT_CARD");  // Ошибка компиляции!
    }
}

Private Methods (Java 9): приватные методы

С Java 9 добавилась возможность приватных методов в интерфейсах:

public interface PaymentService {
    void processPayment(Double amount);
    
    // Default метод
    default void processWithValidation(Double amount) {
        if (validate(amount)) {  // Используем приватный метод
            processPayment(amount);
        }
    }
    
    // ✅ Приватный метод (Java 9+)
    private boolean validate(Double amount) {
        return amount > 0 && amount < 1000000;
    }
    
    // Можно также приватный static метод
    private static void log(String message) {
        System.out.println("[LOG] " + message);
    }
    
    default void logTransaction(String details) {
        log("Transaction: " + details);  // Используем приватный static метод
    }
}

Sealed Interfaces (Java 17): запечатанные интерфейсы

Java 17 добавила sealed интерфейсы — ограничиваются те классы, которые могут их реализовать:

// ✅ Только указанные классы могут реализовать интерфейс
public sealed interface Payment permits CreditCardPayment, PayPalPayment, BankTransfer {
    void process(Double amount);
    
    default void log() {
        System.out.println("Processing payment...");
    }
}

public final class CreditCardPayment implements Payment {
    @Override
    public void process(Double amount) {
        // ...
    }
}

public final class PayPalPayment implements Payment {
    @Override
    public void process(Double amount) {
        // ...
    }
}

public final class BankTransfer implements Payment {
    @Override
    public void process(Double amount) {
        // ...
    }
}

// ❌ Эта реализация компилироваться не будет
// public class CustomPayment implements Payment { ... }  // Ошибка!

Практический пример: иерархия интерфейсов

// Базовый интерфейс с приватными и public default методами
public interface DataRepository<T> {
    T findById(Long id);
    
    // Default методы
    default List<T> findAll() {
        return new ArrayList<>();
    }
    
    default void save(T entity) {
        validate(entity);
        performSave(entity);
    }
    
    // Абстрактный метод для реализующих классов
    void performSave(T entity);
    
    // Приватный метод (Java 9+)
    private void validate(T entity) {
        if (entity == null) {
            throw new IllegalArgumentException("Entity cannot be null");
        }
    }
    
    // Static factory method
    static <T> DataRepository<T> inMemory() {
        return new InMemoryRepository<>();
    }
}

// Конкретная реализация
public class UserRepository implements DataRepository<User> {
    private final Map<Long, User> storage = new HashMap<>();
    
    @Override
    public User findById(Long id) {
        return storage.get(id);
    }
    
    @Override
    public void performSave(User user) {
        storage.put(user.getId(), user);
        System.out.println("User saved: " + user.getName());
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        UserRepository repo = new UserRepository();
        
        User user = new User(1L, "John");
        
        // Использование default метода
        repo.save(user);  // Выведет: "User saved: John"
        
        // Использование default findAll (из интерфейса)
        List<User> users = repo.findAll();
        
        // Использование static factory method
        DataRepository<User> inMemoryRepo = DataRepository.inMemory();
    }
}

Множественное наследование интерфейсов

С default методами появилась проблема «Diamond Problem»:

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

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

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

// ❌ АМБИГУОЗНОСТЬ: какой метод вызвать?
public class Implementation implements B, C {
    // ❌ Ошибка компиляции: конфликт методов
    // Нужно явно переопределить
    @Override
    public void method() {
        B.super.method();  // или C.super.method()
    }
}

Отличия между разными типами методов в интерфейсе

Резюме: эволюция интерфейсов Java

Java 1.0: Только абстрактные методы

public interface OldInterface {
    void doSomething();
}

Java 8: Default и static методы

public interface ModernInterface {
    void doSomething();
    default void helper() { ... }
    static void factory() { ... }
}

Java 9: Приватные методы

public interface PrivateInterface {
    default void doSomething() {
        helper();  // используем приватный метод
    }
    private void helper() { ... }
}

Java 17: Sealed интерфейсы

public sealed interface SealedInterface permits OnlyA, OnlyB {
    // Только OnlyA и OnlyB могут реализовать
}

ГЛАВНОЕ: Default методы в интерфейсах — это мост между абстракцией и реализацией, обеспечивающий обратную совместимость и удобство разработки!