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

Дефолтные методы в интерфейсах и абстрактных классах

Дефолтные методы были введены в Java 8 и предоставляют реализацию "по умолчанию" в интерфейсах. Это изменило подход к разработке Java-приложений.

Дефолтные методы в интерфейсах

Дефолтные методы имеют реализацию и помечаются словом default:

public interface Animal {
    // Абстрактный метод — должен быть реализован
    void makeSound();
    
    // Дефолтный метод — имеет реализацию
    default void sleep() {
        System.out.println("Животное спит");
    }
    
    default void eat() {
        System.out.println("Животное ест");
    }
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Гав!");
    }
    
    // sleep() и eat() наследуются автоматически
    // Не нужно реализовывать дефолтные методы
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Гав!
        dog.sleep();      // Животное спит (дефолтная реализация)
        dog.eat();        // Животное ест (дефолтная реализация)
    }
}

Переопределение дефолтных методов

Можно переопределить дефолтный метод для специфичной реализации:

public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Мяу!");
    }
    
    // Переопределяем дефолтный метод для кошки
    @Override
    public void sleep() {
        System.out.println("Кошка дремлет на диване");
    }
    
    // eat() остается как в интерфейсе
}

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

Проблема возникает, если класс реализует несколько интерфейсов с одинаковыми дефолтными методами:

public interface Swimmer {
    default void move() {
        System.out.println("Плывет");
    }
}

public interface Runner {
    default void move() {
        System.out.println("Бежит");
    }
}

// Это вызовет ошибку компиляции:
public class Duck implements Swimmer, Runner {
    // ERROR: Ambiguous method — какой move() использовать?
}

// Решение: явно переопределить
public class Duck implements Swimmer, Runner {
    @Override
    public void move() {
        System.out.println("Утка и плывет, и летает");
    }
}

// Или вызвать нужный интерфейс явно:
public class Duck implements Swimmer, Runner {
    @Override
    public void move() {
        Swimmer.super.move();  // Плывет
        Runner.super.move();   // Бежит
    }
}

Статические методы в интерфейсах (Java 8+)

Также можно добавлять статические методы в интерфейсы:

public interface Utils {
    static void printInfo() {
        System.out.println("Это утилита");
    }
}

// Вызов:
Utils.printInfo(); // Это утилита

Приватные методы в интерфейсах (Java 9+)

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

public interface DataProcessor {
    default void processData(List<Integer> data) {
        validate(data);
        transform(data);
        output(data);
    }
    
    private void validate(List<Integer> data) {
        if (data == null || data.isEmpty()) {
            throw new IllegalArgumentException("Data is empty");
        }
    }
    
    private void transform(List<Integer> data) {
        data.replaceAll(x -> x * 2);
    }
    
    private void output(List<Integer> data) {
        data.forEach(System.out::println);
    }
}

public class MyProcessor implements DataProcessor {
    // Все приватные методы используются внутри processData
}

Дефолтные методы vs Абстрактные классы

Использование дефолтных методов:

• Когда нужно добавить функцию к существующему интерфейсу без поломки имплементаций
• Когда логика касается только одной ответственности интерфейса
• Когда нужна множественная реализация

Использование абстрактных классов:

• Когда нужны поля (состояние)
• Когда нужны конструкторы
• Когда нужны защищенные методы (protected)
• Когда есть иерархия наследования

// Интерфейс с дефолтными методами
public interface DataSource {
    Connection getConnection();
    
    default void closeConnection(Connection conn) {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

// Абстрактный класс — для иерархии и состояния
public abstract class BaseService {
    protected String name;  // Состояние
    protected int timeout;  // Состояние
    
    public BaseService(String name, int timeout) {  // Конструктор
        this.name = name;
        this.timeout = timeout;
    }
    
    protected void log(String message) {  // Защищенный метод
        System.out.println("[" + name + "] " + message);
    }
    
    abstract void execute();  // Абстрактный метод
}

Практический пример

public interface Repository<T> {
    T findById(Long id);
    void save(T entity);
    
    // Дефолтный метод, который можно переопределить
    default void delete(T entity) {
        System.out.println("Удаляется: " + entity);
    }
    
    // Приватный метод для логирования
    private void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

public class UserRepository implements Repository<User> {
    @Override
    public User findById(Long id) {
        return new User(id, "John");
    }
    
    @Override
    public void save(User entity) {
        System.out.println("Сохраняется пользователь: " + entity.getName());
    }
    
    // delete() переопределяем для специфичного поведения
    @Override
    public void delete(User entity) {
        System.out.println("Мягкое удаление пользователя: " + entity.getName());
    }
}

Итог

• Дефолтные методы позволяют добавлять функции без поломки существующего кода
• Абстрактные классы лучше для иерархии и состояния
• Приватные методы в интерфейсах помогают избежать дублирования логики
• Дефолтные методы часто используются в современных Java фреймворках (Spring, Collections API)