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

Ответ

В Java это решается просто и элегантно благодаря тому, что методы с одинаковой сигнатурой рассматриваются как один и тот же метод.

1. Простой случай — методы полностью идентичны

public interface InterfaceA {
    void doSomething();
    String getName();
}

public interface InterfaceB {
    void doSomething();
    String getName();
}

public class MyClass implements InterfaceA, InterfaceB {
    @Override
    public void doSomething() {
        System.out.println("Выполняю работу");
    }
    
    @Override
    public String getName() {
        return "MyClass";
    }
}

Это работает потому что в Java методы с одинаковой сигнатурой (имя + параметры + возвращаемый тип) считаются одним и тем же методом. Реализация одного метода автоматически удовлетворяет оба интерфейса.

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

public interface InterfaceA {
    default String process(String input) {
        return "A: " + input;
    }
}

public interface InterfaceB {
    default String process(String input) {
        return "B: " + input;
    }
}

public class MyClass implements InterfaceA, InterfaceB {
    @Override
    public String process(String input) {
        // Должны явно переопределить, так как есть конфликт
        // Можем выбрать один из подходов:
        // 1. Своя реализация
        return "Custom: " + input;
        
        // 2. Делегировать одному интерфейсу
        // return InterfaceA.super.process(input);
        
        // 3. Объединить оба
        // return InterfaceA.super.process(input) + " & " + InterfaceB.super.process(input);
    }
}

3. Интерфейсы с различными возвращаемыми типами (ковариантность)

public interface InterfaceA {
    Number getValue();
}

public interface InterfaceB {
    Integer getValue();  // Integer это подтип Number
}

public class MyClass implements InterfaceA, InterfaceB {
    @Override
    public Integer getValue() {
        return 42;
    }
    // Integer удовлетворяет оба контракта
}

4. Сложный пример с generics

public interface Reader<T> {
    T read();
}

public interface Converter<T> {
    T read();  // Та же сигнатура
}

public class StringReader implements Reader<String>, Converter<String> {
    @Override
    public String read() {
        return "Hello";
    }
}

// Использование
StringReader reader = new StringReader();
reader.read();  // Работает для обоих интерфейсов

5. Проблема: Методы с одинаковой сигнатурой но разными исключениями

public interface InterfaceA {
    void process() throws IOException;
}

public interface InterfaceB {
    void process() throws SQLException;
}

public class MyClass implements InterfaceA, InterfaceB {
    @Override
    public void process() throws IOException, SQLException {
        // Должны выбросить оба типа исключений
        // или общий предок Exception
    }
}

6. Использование Adapter Pattern для сложных случаев

public interface LegacyInterface {
    void oldMethod();
}

public interface ModernInterface {
    void oldMethod();  // Переименована в новом API, но сигнатура та же
}

public class AdapterClass implements LegacyInterface, ModernInterface {
    @Override
    public void oldMethod() {
        // Одна реализация для обоих интерфейсов
        System.out.println("Обработка для обоих интерфейсов");
    }
}

7. Интерфейсы с методами разных сигнатур

public interface InterfaceA {
    void doSomething();
    String getValue();
}

public interface InterfaceB {
    void doSomething();  // Одинаковая
    Integer getValue();  // Разная сигнатура (но ковариантна)
    String getStatus();  // Только в B
}

public class MyClass implements InterfaceA, InterfaceB {
    @Override
    public void doSomething() {
        // Реализуем один раз
    }
    
    @Override
    public Integer getValue() {
        // Если возвращаемый тип подтип, это работает
        return 42;
    }
    
    @Override
    public String getStatus() {
        return "OK";
    }
}

Правила Java для множественной имплементации

1. Методы с одинаковой сигнатурой — реализуются один раз
2. Default методы конфликтуют — нужна явная переопределение
3. Ковариантные возвращаемые типы — допускаются (подтипы)
4. Различные checked exceptions — должны быть объявлены в реализации
5. Static методы — не наследуются, не создают конфликтов

Практический пример из реальных проектов

// JDK example
public class LinkedHashMap<K, V> 
    extends HashMap<K, V> 
    implements Map<K, V>, Cloneable, Serializable {
    // Map и Cloneable имеют методы с одинаковыми сигнатурами
    // Но реализуются один раз в LinkedHashMap
}

// Spring framework
public class JdbcTemplate 
    implements JdbcOperations {
    // Реализует интерфейсы с методами одинаковых сигнатур
}

В своём опыте я часто встречал такие ситуации при работе с наследованием интерфейсов и создании адаптеров для обеспечения обратной совместимости.