Могут ли в функциональном интерфейсе быть анонимные и неанонимные default-методы

Default-методы в функциональных интерфейсах

Функциональный интерфейс — это интерфейс с ровно одним абстрактным методом. Однако он может содержать неограниченное количество default-методов. Это важное отличие, которое часто путают.

Определение функционального интерфейса

// ПРАВИЛЬНО: функциональный интерфейс
@FunctionalInterface
public interface StringProcessor {
    // Единственный абстрактный метод
    String process(String input);
    
    // Default-методы ДОПУСКАЮТСЯ!
    default void print(String message) {
        System.out.println(message);
    }
    
    default String repeat(String s, int times) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < times; i++) {
            sb.append(s);
        }
        return sb.toString();
    }
    
    // Статические методы тоже ДОПУСКАЮТСЯ
    static StringProcessor identity() {
        return str -> str;
    }
}

Это ФУНКЦИОНАЛЬНЫЙ интерфейс, потому что есть только 1 абстрактный метод (process).

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

1. Default-методы в стандартных функциональных интерфейсах

// Пример из Java API: Function<T, R>
public interface Function<T, R> {
    // Единственный абстрактный метод
    R apply(T t);
    
    // Default-методы
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    
    // Статический метод
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Использование:

public static void main(String[] args) {
    Function<String, Integer> toLength = s -> s.length();
    Function<Integer, String> toString = n -> "Length: " + n;
    
    // Используем default-метод andThen
    Function<String, String> composed = toLength.andThen(toString);
    System.out.println(composed.apply("Hello")); // "Length: 5"
}

2. Наша реализация с default-методами

@FunctionalInterface
public interface Calculator {
    // Единственный абстрактный метод
    int calculate(int a, int b);
    
    // Default-методы для расширения функциональности
    default int calculateDouble(int a, int b) {
        return calculate(a, b) * 2;
    }
    
    default String calculateAndFormat(int a, int b) {
        int result = calculate(a, b);
        return String.format("Результат: %d", result);
    }
    
    default void printResult(int a, int b) {
        System.out.println("Результат: " + calculate(a, b));
    }
    
    // Статические методы
    static Calculator add() {
        return (a, b) -> a + b;
    }
    
    static Calculator multiply() {
        return (a, b) -> a * b;
    }
}

Использование:

public static void main(String[] args) {
    Calculator add = Calculator.add();
    Calculator multiply = Calculator.multiply();
    
    // Используем абстрактный метод
    System.out.println(add.calculate(5, 3));        // 8
    
    // Используем default-методы
    System.out.println(add.calculateDouble(5, 3));   // 16
    System.out.println(add.calculateAndFormat(5, 3)); // "Результат: 8"
    add.printResult(5, 3);                            // "Результат: 8"
    
    System.out.println(multiply.calculate(5, 3));    // 15
}

Анонимные классы с default-методами

public static void main(String[] args) {
    // Анонимный класс, реализующий функциональный интерфейс
    Calculator add = new Calculator() {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
        
        // Можем переопределить default-методы если нужно
        @Override
        public void printResult(int a, int b) {
            System.out.println("Сумма: " + calculate(a, b));
        }
    };
    
    add.printResult(5, 3);  // "Сумма: 8"
}

Важное различие: Named vs Anonymous

Анонимные default-методы (в контексте Java):

• Это методы, которые не имеют имени (например, lambda-выражения)
• Lambda захватывает ОДНО действие (абстрактный метод)
• Default-методы в интерфейсе — это НЕ анонимные, это именованные методы

// Lambda — это анонимная реализация абстрактного метода
Calculator add = (a, b) -> a + b;

// Но default-методы остаются именованными
add.calculateDouble(5, 3);  // calculateDouble — имеет имя
add.printResult(5, 3);      // printResult — имеет имя

Нельзя создать анонимный default-метод:

// НЕВОЗМОЖНО и СИНТАКСИЧЕСКИ НЕПРАВИЛЬНО
public interface BadInterface {
    // Нельзя создать default-метод без имени
    // default { // Ошибка компиляции!
    //     System.out.println("What?");
    // }
}

Правила для функциональных интерфейсов

@FunctionalInterface
public interface ValidFunctionalInterface {
    // ✅ 1 абстрактный метод
    void doSomething();
    
    // ✅ Любое количество default-методов
    default void method1() {}
    default void method2() {}
    default void method3() {}
    
    // ✅ Любое количество статических методов
    static void staticMethod1() {}
    static void staticMethod2() {}
    
    // ✅ Методы из Object (не считаются абстрактными)
    @Override
    String toString();
    
    @Override
    boolean equals(Object obj);
}

// ❌ ОШИБКА: 2 абстрактных метода
@FunctionalInterface
public interface InvalidInterface {
    void method1();
    void method2();  // Компилятор выдаст ошибку!
}

Default-методы в функциональных интерфейсах: реальный пример

// Функциональный интерфейс с полезными default-методами
@FunctionalInterface
public interface ThrowableFunction<T, R> {
    // Единственный абстрактный метод (может выбросить исключение)
    R apply(T t) throws Exception;
    
    // Default-метод: обработка исключений
    default R applyUnchecked(T t) {
        try {
            return apply(t);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // Default-метод: логирование
    default ThrowableFunction<T, R> withLogging(String operationName) {
        return t -> {
            System.out.println("Начало: " + operationName);
            R result = apply(t);
            System.out.println("Завершено: " + operationName);
            return result;
        };
    }
    
    // Композиция
    default <V> ThrowableFunction<V, R> compose(ThrowableFunction<? super V, ? extends T> before) {
        return v -> apply(before.apply(v));
    }
}

// Использование
public static void main(String[] args) throws Exception {
    ThrowableFunction<String, Integer> parseToLength = s -> {
        if (s == null) throw new IllegalArgumentException("Null input");
        return s.length();
    };
    
    // Используем default-метод
    ThrowableFunction<String, Integer> withLogging = 
        parseToLength.withLogging("String parsing");
    
    Integer result = withLogging.applyUnchecked("Hello");
    // Вывод:
    // Начало: String parsing
    // Завершено: String parsing
}

Сравнение: Функциональный vs Обычный интерфейс

// ФУНКЦИОНАЛЬНЫЙ интерфейс (1 абстрактный метод)
@FunctionalInterface
public interface Comparator1 {
    int compare(Object a, Object b);  // 1 абстрактный
    
    default boolean isEqual(Object a, Object b) {
        return compare(a, b) == 0;
    }
}

// ОБЫЧНЫЙ интерфейс (2+ абстрактных методов)
public interface Comparator2 {
    int compare(Object a, Object b);
    boolean isEqual(Object a, Object b);  // 2й абстрактный метод
    
    default void print() {}
}

Ключевые правила

1. Функциональный интерфейс имеет ровно 1 абстрактный метод
2. Default-методы — это именованные методы с реализацией
3. Default-методы ДОПУСКАЮТСЯ в функциональных интерфейсах
4. Статические методы тоже допускаются
5. Методы из Object (equals, hashCode, toString) не считаются абстрактными
6. Анонимные методы невозможны — каждый метод имеет имя

Заключение

Ответ: ДА, функциональный интерфейс может содержать default-методы. Это именованные методы с реализацией, а не анонимные. Важно помнить, что функциональность интерфейса определяется количеством абстрактных методов (ровно 1), а не количеством default-методов. Default-методы только дополняют функциональность, не влияя на определение функционального интерфейса.