Lambda expressions become truly useful when you understand the type they work with. In Java, that type is usually a functional interface. A functional interface provides a contract containing exactly one abstract method, and a lambda expression provides the implementation of that method.
This relationship is one of the most important ideas in Java's functional programming features. Once you understand it, interfaces such as Predicate, Consumer, Supplier, and Function become much easier to understand.
What Is a Functional Interface?
A functional interface is an interface that contains exactly one abstract method. It can contain additional default and static methods because those methods already have implementations.
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
}
The Calculator interface is functional because it has only one abstract method: calculate().
A lambda expression can provide the implementation:
Calculator addition = (a, b) -> a + b; System.out.println(addition.calculate(10, 20));
The lambda does not replace the interface. Instead, it supplies the behavior required by the interface's single abstract method.
The @FunctionalInterface Annotation
Java provides the @FunctionalInterface annotation to explicitly indicate that an interface is intended to be functional.
@FunctionalInterface
interface Greeting {
void greet();
}
The annotation is not mandatory. An interface with one abstract method can still be a functional interface without it. However, using the annotation is a good practice because the compiler can verify your intention.
Important: If an interface marked with @FunctionalInterface contains more than one abstract method, the compiler reports an error.
Why Functional Interfaces Exist
Traditional interfaces are excellent for defining contracts between classes. Functional interfaces take that idea one step further by allowing behavior to be passed as a value.
For example, imagine a method that needs to decide whether a number is valid. Instead of creating a separate class for every possible rule, you can pass different lambda expressions implementing the same functional interface.
@FunctionalInterface
interface NumberTest {
boolean test(int number);
}
public class Main {
static void checkNumber(int number, NumberTest test) {
System.out.println(test.test(number));
}
public static void main(String[] args) {
checkNumber(20, number -> number > 10);
checkNumber(20, number -> number % 2 == 0);
}
}
The method checkNumber() does not need to know which rule will be used. The behavior is supplied by the lambda.
One Abstract Method Rule
The central rule is simple: a functional interface must have exactly one abstract method.
| Interface Structure | Functional? | Reason |
|---|---|---|
| One abstract method | Yes | Meets the functional interface contract |
| Two abstract methods | No | Lambda would not know which method to implement |
| One abstract + default methods | Yes | Default methods already have implementations |
| One abstract + static methods | Yes | Static methods are not abstract instance methods |
Functional Interface with a Default Method
A functional interface may contain default methods in addition to its single abstract method.
@FunctionalInterface
interface Printer {
void print(String message);
default void showInfo() {
System.out.println("Printer is ready.");
}
}
The interface remains functional because showInfo() already has an implementation.
Functional Interface with a Static Method
Static methods are also allowed.
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
static void info() {
System.out.println("Calculator interface");
}
}
The static method does not become an abstract method, so the interface still contains only one abstract method.
Using a Lambda with a Custom Functional Interface
@FunctionalInterface
interface MathOperation {
int operate(int a, int b);
}
public class Main {
public static void main(String[] args) {
MathOperation add = (a, b) -> a + b;
MathOperation multiply = (a, b) -> a * b;
System.out.println(add.operate(5, 3));
System.out.println(multiply.operate(5, 3));
}
}
Both lambdas implement the same functional interface, but they provide different behavior. This is a powerful design pattern because the method contract stays stable while the behavior can change.
Passing a Functional Interface to a Method
Functional interfaces become particularly useful when passed as method parameters.
@FunctionalInterface
interface Operation {
int execute(int a, int b);
}
public class Main {
static int calculate(int a, int b, Operation operation) {
return operation.execute(a, b);
}
public static void main(String[] args) {
int result = calculate(10, 5, (a, b) -> a - b);
System.out.println(result);
}
}
The calculate() method receives behavior as an argument. This makes the method flexible without requiring multiple overloaded methods for every possible operation.
Functional Interface and Anonymous Class
Before lambda expressions, the same behavior could be implemented with an anonymous class.
Operation subtraction = new Operation() {
@Override
public int execute(int a, int b) {
return a - b;
}
};
The lambda version is much shorter:
Operation subtraction = (a, b) -> a - b;
Both approaches implement the same functional interface. The lambda simply provides a more concise way to express the behavior.
Built-In Functional Interfaces
Java already provides many commonly used functional interfaces in the java.util.function package. You usually do not need to create a custom interface when one of the standard interfaces already describes your requirement.
| Interface | Input | Output | Typical Use |
|---|---|---|---|
| Predicate<T> | One value | boolean | Testing a condition |
| Consumer<T> | One value | void | Performing an action |
| Supplier<T> | None | T | Providing a value |
| Function<T, R> | One value | R | Transforming a value |
Predicate Example
A Predicate represents a condition that produces either true or false.
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) {
Predicate<Integer> isEven = number -> number % 2 == 0;
System.out.println(isEven.test(10));
System.out.println(isEven.test(7));
}
}
The lambda receives an integer and returns a boolean result. The test() method executes the predicate.
Consumer Example
A Consumer accepts a value and performs an operation without returning a result.
import java.util.function.Consumer;
public class Main {
public static void main(String[] args) {
Consumer<String> printer =
message -> System.out.println(message);
printer.accept("Learning Java");
}
}
The accept() method supplies the value to the consumer.
Supplier Example
A Supplier does not receive an input value. Instead, it produces or supplies a value.
import java.util.function.Supplier;
public class Main {
public static void main(String[] args) {
Supplier<String> message =
() -> "Java is powerful";
System.out.println(message.get());
}
}
The get() method obtains the supplied value.
Function Example
A Function accepts one value and transforms it into another value.
import java.util.function.Function;
public class Main {
public static void main(String[] args) {
Function<String, Integer> length =
text -> text.length();
System.out.println(length.apply("Java"));
}
}
The input type is String, while the result type is Integer. The apply() method performs the transformation.
When to Create a Custom Functional Interface
Standard interfaces should be your first choice when they clearly represent the required behavior. A custom functional interface is useful when the operation has a domain-specific meaning or when a custom method name makes the code easier to understand.
@FunctionalInterface
interface DiscountCalculator {
double calculateDiscount(double price);
}
The custom name DiscountCalculator communicates the purpose more clearly than a generic interface in some business applications.
Common Beginner Mistakes
- Creating a functional interface with more than one abstract method.
- Thinking that @FunctionalInterface itself makes an interface functional.
- Assuming default and static methods count as additional abstract methods.
- Creating custom interfaces when a standard interface such as Predicate or Function would be clearer.
- Forgetting that a lambda must match the parameter and return types of its target functional interface.
Best Practices
- Use @FunctionalInterface when defining your own functional interfaces.
- Prefer Java's standard functional interfaces when they naturally fit the requirement.
- Keep functional interfaces focused on one clear responsibility.
- Use meaningful custom interface names when domain-specific behavior improves readability.
- Keep lambda implementations small and easy to understand.
Interview Insight
A functional interface has exactly one abstract method, but it may contain multiple default and static methods. The @FunctionalInterface annotation is optional, but it allows the compiler to verify that the interface follows the functional-interface contract.
Quick Revision
| Concept | Key Point |
|---|---|
| Functional Interface | Contains exactly one abstract method |
| @FunctionalInterface | Asks the compiler to verify the functional-interface contract |
| Lambda | Provides an implementation for the abstract method |
| Default Method | Allowed because it already has an implementation |
| Static Method | Allowed because it is not an abstract instance method |
| Custom Interface | Useful for domain-specific behavior |
| Standard Interface | Prefer when Predicate, Consumer, Supplier, Function, or another existing type fits |
Final Takeaway
Functional interfaces provide the bridge between Java's traditional object-oriented design and its functional programming features. The rule is simple: one abstract method defines the contract, and a lambda can provide its behavior. Once this relationship becomes familiar, standard interfaces such as Predicate, Consumer, Supplier, and Function feel much less mysterious and become practical tools for writing flexible, expressive Java applications.