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

Да, интерфейсы можно наследовать. Это мощный механизм расширения контрактов

Наследование интерфейсов — это явление, когда один интерфейс расширяет другой интерфейс, наследуя его методы и добавляя новые. Это позволяет создавать иерархии абстрактных контрактов.

Основы: extends для интерфейсов

В отличие от классов, интерфейс может наследовать несколько других интерфейсов:

// Базовый интерфейс А
public interface Animal {
    void eat();
    void sleep();
}

// Интерфейс В наследует А и добавляет свои методы
public interface Predator extends Animal {
    void hunt();
    void roar();
}

// Интерфейс С наследует А
public interface Pet extends Animal {
    void play();
    void train();
}

// Интерфейс D наследует оба Predator и Pet (множественное наследование)
public interface DomesticatedPredator extends Predator, Pet {
    void purr();
}

// Реализующий класс должен реализовать ВСЕ методы из цепочки
public class Cat implements DomesticatedPredator {
    @Override
    public void eat() {
        System.out.println("Кот ест рыбу");
    }

    @Override
    public void sleep() {
        System.out.println("Кот спит на диване");
    }

    @Override
    public void hunt() {
        System.out.println("Кот охотится на мышей");
    }

    @Override
    public void roar() {
        System.out.println("Мяу!");
    }

    @Override
    public void play() {
        System.out.println("Кот играет с клубком");
    }

    @Override
    public void train() {
        System.out.println("Кот учится команде Сидеть");
    }

    @Override
    public void purr() {
        System.out.println("Кот мурлычет");
    }
}

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

Один интерфейс может наследовать несколько других интерфейсов (что классы не могут делать):

public interface Swimmer {
    void swim();
}

public interface Flyer {
    void fly();
}

public interface Runner {
    void run();
}

// Одна сущность может иметь несколько способностей
public interface SuperAnimal extends Swimmer, Flyer, Runner {
    void superPower();
}

// Утка реализует плавание и полёт
public class Duck implements Swimmer, Flyer {
    @Override
    public void swim() {
        System.out.println("Утка плывёт");
    }

    @Override
    public void fly() {
        System.out.println("Утка летит");
    }
}

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

Когда два интерфейса имеют методы с одинаковой сигнатурой, это НЕ конфликт — это просто один метод:

public interface A {
    void doSomething();
    default void log() {
        System.out.println("Log A");
    }
}

public interface B {
    void doSomething();
    default void log() {
        System.out.println("Log B");
    }
}

// Конфликт default методов!
public interface C extends A, B {
    @Override
    default void log() {
        // ДОЛЖНЫ разрешить конфликт
        A.super.log();
        B.super.log();
    }
}

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

Java 8+ позволяет интерфейсам иметь default методы с реализацией:

public interface Logger {
    default void log(String message) {
        System.out.println("[LOG] " + message);
    }
    
    default void error(String message) {
        System.out.println("[ERROR] " + message);
    }
}

public interface Database extends Logger {
    void connect();
    void disconnect();
    
    @Override
    default void log(String message) {
        System.out.println("[DB] " + message);  // Переопределение
    }
}

public class PostgreSQL implements Database {
    @Override
    public void connect() {
        log("Подключение к PostgreSQL");
    }

    @Override
    public void disconnect() {
        log("Отключение от PostgreSQL");
    }
}

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

public interface DatabaseFactory {
    static Database createPostgreSQL() {
        return new PostgreSQL();
    }
    
    static Database createMySQL() {
        return new MySQL();
    }
}

// Использование
Database db = DatabaseFactory.createPostgreSQL();

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

// Уровень 1: Основной контракт
public interface Repository<T> {
    Optional<T> findById(Long id);
    List<T> findAll();
    void save(T entity);
    void delete(T entity);
}

// Уровень 2: Специализированные контракты
public interface ReadOnlyRepository<T> extends Repository<T> {
    @Override
    default void save(T entity) {
        throw new UnsupportedOperationException("Чтение только");
    }
    
    @Override
    default void delete(T entity) {
        throw new UnsupportedOperationException("Чтение только");
    }
}

public interface CachedRepository<T> extends Repository<T> {
    void clearCache();
    boolean isCached(Long id);
}

// Уровень 3: Комбинированный контракт
public interface SmartRepository<T> extends ReadOnlyRepository<T>, CachedRepository<T> {
    void warmUpCache();
}

Когда использовать наследование интерфейсов

Вывод

Да, интерфейсы полностью поддерживают наследование. Особенности:

• Один интерфейс может наследовать несколько других
• Наследуются все методы в полной цепочке
• Default методы могут быть переопределены
• Static методы наследуются, но не переопределяются
• Конфликты разрешаются явным переопределением