Считается ли интерфейс с одним методом по умолчанию функциональным

Считается ли интерфейс с одним методом по умолчанию функциональным

Да, интерфейс с одним методом абстрактным методом по умолчанию считается функциональным интерфейсом (Functional Interface) в Java. Это одна из ключевых концепций, введённых в Java 8.

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

Функциональный интерфейс — это интерфейс, который содержит ровно один абстрактный метод. Он может иметь любое количество методов по умолчанию (default methods) и статических методов, но только один неопределённый метод.

Правильная аннотация

Нужно использовать аннотацию @FunctionalInterface:

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Эта аннотация:

• Задокументирует намерение о функциональной природе интерфейса
• Проверит на этапе компиляции, что интерфейс действительно имеет один абстрактный метод
• Если случайно добавить второй абстрактный метод, компилятор выбросит ошибку

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

// Пример 1: Простой функциональный интерфейс
@FunctionalInterface
public interface Printer {
    void print(String message);
}

// Пример 2: С методами по умолчанию
@FunctionalInterface
public interface Converter<T, R> {
    R convert(T input);
    
    default void log(String msg) {
        System.out.println("Log: " + msg);
    }
}

// Пример 3: Со статическими методами
@FunctionalInterface
public interface Factory<T> {
    T create();
    
    static <T> Factory<T> cached(Factory<T> factory) {
        return () -> factory.create();
    }
}

Использование с Lambda-выражениями

Функциональные интерфейсы — это основа lambda-выражений в Java. Lambda может напрямую реализовать функциональный интерфейс:

// Без lambda (анонимный класс)
Calculator calc = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// С lambda (гораздо лаконичнее)
Calculator calc = (a, b) -> a + b;

Встроенные функциональные интерфейсы

Java предоставляет множество встроенных функциональных интерфейсов в пакете java.util.function:

// Function<T, R> - преобразует T в R
Function<String, Integer> stringLength = String::length;

// Consumer<T> - принимает T и ничего не возвращает
Consumer<String> printer = System.out::println;

// Supplier<T> - ничего не принимает, возвращает T
Supplier<String> greeting = () -> "Hello";

// Predicate<T> - проверяет условие
Predicate<Integer> isEven = x -> x % 2 == 0;

// BiFunction<T, U, R> - принимает два параметра
BiFunction<Integer, Integer, Integer> sum = Integer::sum;

Stream API и функциональные интерфейсы

Функциональные интерфейсы — это основа Stream API:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// map требует Function<Integer, Integer>
List<Integer> squared = numbers.stream()
    .map(x -> x * x)
    .collect(Collectors.toList());

// filter требует Predicate<Integer>
List<Integer> evenNumbers = numbers.stream()
    .filter(x -> x % 2 == 0)
    .collect(Collectors.toList());

// forEach требует Consumer<Integer>
numbers.forEach(System.out::println);

Важные моменты

1. Аннотация не обязательна

Интерфейс считается функциональным даже без аннотации @FunctionalInterface, но её наличие повышает читаемость и добавляет проверку на компиляции.

2. Методы из Object не считаются

Если интерфейс переопределяет методы Object (equals, hashCode, toString), они не считаются абстрактными методами интерфейса:

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
    
    @Override
    String toString(); // Не считается вторым абстрактным методом
}

3. Backward compatibility

Этот подход сохраняет совместимость с интерфейсами, созданными до Java 8, если они имеют один метод.

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

@FunctionalInterface
public interface DataProcessor {
    String process(String data);
    
    default String processWithLog(String data) {
        System.out.println("Processing: " + data);
        return process(data);
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        DataProcessor upperCase = String::toUpperCase;
        DataProcessor reverse = s -> new StringBuilder(s).reverse().toString();
        
        System.out.println(upperCase.processWithLog("hello")); // HELLO
        System.out.println(reverse.processWithLog("hello")); // olleh
    }
}

Функциональные интерфейсы — это фундамент функционального программирования в Java 8+. Их понимание критично для работы с лямбда-выражениями и Stream API.