Default and Static Methods Don't Count
You'll learn why @FunctionalInterface permits unlimited default and static methods without breaking the "single abstract method" rule.
The Core Idea
When the compiler checks whether an interface qualifies as a functional interface (one abstract method only), it completely ignores default and static methods. Only abstract methods count toward the SAM (Single Abstract Method) requirement. This means you can add as many default and static methods as you want—they don't affect lambda compatibility.
Why They Don't Count
Think of a functional interface like a contract with one job opening (the abstract method). Default methods are like "helpful tools included with the contract"—they have implementations already, so the lambda doesn't need to provide them. Static methods are like "utility functions attached to the contract itself"—they exist independently and aren't part of what the implementer must do.
Since lambdas only implement the single abstract method, additional default or static methods are invisible to the lambda. They're just bonus features on the interface.
Example Structure
@FunctionalInterface
public interface DataProcessor {
// THIS is the one abstract method (lambda implements this)
String process(String data);
// These DON'T count - default method has implementation
default String processWithLogging(String data) {
System.out.println("Processing: " + data);
return process(data);
}
// This DOESN'T count - static method
static String sanitize(String input) {
return input.trim();
}
}
The lambda only needs to implement process(). The other methods are already complete or belong to the class itself.
Key Takeaway: @FunctionalInterface allows unlimited default and static methods because only abstract methods determine lambda implementation requirements—default methods have bodies, and static methods aren't instance-dependent.