1.2. Functional Interfaces

A functional interface is an interface with only one abstract method. It can have multiple default or static methods.

A functional interface is a type of interface that allows you to define a contract with a single abstract method. This means that the interface can define one main action that implementing classes must provide. However, it can also include default methods (methods with an implementation) and static methods, which can be called without an instance of the interface. This is significant because it allows for flexibility while ensuring that there’s only one main behavior that subclasses must implement.

Consider a remote control for a TV. The remote can have different buttons for various functions like power on/off (the main task), volume control, and channel change (the default methods). Even though the remote has multiple buttons, the most important function is to turn the TV on and off, similar to how a functional interface focuses on a single main action.

@FunctionalInterface
interface MyFunctionalInterface {
    void execute();
}

The syntax for declaring a functional interface includes the annotation @FunctionalInterface, followed by the interface declaration. The interface must contain exactly one abstract method. The execute() method in this case is the one that has to be implemented by any class that uses this functional interface. This clear structure helps in leveraging Java’s functional programming capabilities easily.

Think of this as creating a template for a magic task. The @FunctionalInterface is like saying, 'This is a special template that only allows one main magic task to be performed, but you can add more optional tools to help with that task.' Just like in a recipe, you might have one main step (baking the cake), but you can still add extra tips (optional ingredients) that don't change the essential method.

You can use this interface with lambda expressions or method references.

Functional interfaces are specifically designed to work seamlessly with lambda expressions. A lambda expression allows you to provide an implementation for the abstract method of the functional interface in a concise way. This means that instead of writing a whole class just to implement one method, you can define the behavior in a single line using the lambda syntax.

Imagine a chef who needs to cook a dish. Instead of writing down a full cookbook (which is like creating a whole class), they can just jot down a single shorthand note (the lambda expression) that directly instructs how to make that specific dish quickly.

• Runnable
• Callable
• Comparator
• ActionListener

Java provides several predefined functional interfaces in the java.util.function package. These interfaces are built for common programming patterns. For instance, Runnable is a functional interface that represents a task to be executed without input parameters, while Callable can return a value after execution. Comparator is used for defining a custom order for objects, and ActionListener is used in GUI programming to handle button clicks and other actions.

Think of these predefined interfaces as ready-to-use tools in a toolbox. Each tool (Runnable, Callable, etc.) serves a specific purpose, making it easier to perform common tasks without having to build custom tools for every new project.

--