Functional Interface in Java
In Java, a functional interface is a special type of interface that defines exactly one abstract method. Because of this characteristic, functional interfaces can be implicitly converted to lambda expressions. Java 8 introduced the concept of functional interfaces as a key foundation for lambda expressions.
Features
Single Abstract Method (SAM): A functional interface contains only one abstract method. This characteristic is known as the “Single Abstract Method” (SAM) principle. This does not mean that a functional interface cannot have other methods; it can have default and static methods.
@FunctionalInterface
Annotation: While not mandatory, it is common practice to use the@FunctionalInterface
annotation on a functional interface. This annotation not only clarifies the intended use of the interface but also ensures that the interface does not accidentally have more than one abstract method during compilation.Compatible with Lambda Expressions: Since a functional interface has only one abstract method, it can be implicitly converted to a lambda expression. This makes functional interfaces ideal for implementing functional programming concepts, such as passing methods as parameters.
Example
A simple example of a functional interface:
1 |
|
You can use a lambda expression to implement this interface:
1 | SimpleFunctionalInterface sfi = () -> System.out.println("Executing..."); |
Built-in Functional Interfaces
Java 8 provides a series of built-in functional interfaces located in the java.util.function
package. Some commonly used ones include:
Predicate<T>
: Takes one argument and returns a boolean value.Consumer<T>
: Takes one argument and returns no result.Function<T, R>
: Takes one argument and returns a result.Supplier<T>
: Takes no arguments and returns a result.UnaryOperator<T>
: Takes one argument of type T and returns a result of type T.BinaryOperator<T>
: Takes two arguments of the same type and returns a result of the same type.
Example of Using Built-in Functional Interfaces
Here are some examples of how to use these built-in functional interfaces with lambda expressions:
1 | import java.util.function.*; |
The introduction of functional interfaces in Java greatly enhances the language’s expressiveness, especially when using lambda expressions and method references. This allows Java to write more concise, flexible, and understandable code, making it an important step forward in modernizing the language.