Functional Interface in Java 8

Direct Answer

A functional interface has one abstract function method, often called its SAM. It may also have default and static methods, and public methods matching Object methods do not add to the count. The optional @FunctionalInterface annotation asks the compiler to verify the rule. Lambdas and method references need a compatible functional-interface target type.

Code Example

import java.util.List;

public class OrderService {
    @FunctionalInterface
    interface OrderValidator {
        boolean isValid(Order order);

        default OrderValidator and(OrderValidator other) {
            return order -> isValid(order) && other.isValid(order);
        }
    }

    record Order(long id, double amount, String status) {}

    List<Order> filterOrders(List<Order> orders, OrderValidator validator) {
        return orders.stream().filter(validator::isValid).toList();
    }

    public static void main(String[] args) {
        var service = new OrderService();
        var orders = List.of(new Order(1L, 100.0, "PENDING"));
        var valid = service.filterOrders(orders, order -> order.amount() > 50);
        System.out.println(valid);
    }
}

Common Mistakes & Pitfalls

• Adding a second abstract method: Freshers often add another abstract method to an interface marked @FunctionalInterface, breaking the SAM rule. The compiler catches this if you use the annotation, but without it you'll get cryptic lambda compilation errors.
• Confusing default methods with abstract methods: Default methods have implementations (the default keyword) so they don't count toward the one-abstract-method limit. Freshers sometimes think any method in the interface breaks the functional interface rule.
• Forgetting the annotation: While @FunctionalInterface is optional, skipping it means you won't get a compile-time error if someone later adds a second abstract method, breaking all the lambdas that use your interface.