Functional Interfaces & Default Methods (Java 8)

Java 8 brought a paradigm shift to how we design interfaces. Before this release, adding a method to an interface meant breaking every single class that implemented it. Java 8 solved this with Default Methods and introduced Functional Interfaces to pave the way for Lambda expressions.

1. Default Methods: Evolution without Breaking

A default method is a method in an interface that has a body. It is marked with the default keyword. This allows you to add new functionality to existing interfaces without forcing classes that implement them to provide an implementation.

public interface vehicle {
    void drive();

    // New functionality added without breaking old classes
    default void honk() {
        System.out.println("Beep beep!");
    }
}

public class Bicycle implements vehicle {
    @Override
    public void drive() {
        System.out.println("Pedaling away...");
    }
    // No need to implement honk(), it uses the default!
}

Why is this important? It allowed the Java team to add methods like forEach() to the Iterable interface without breaking millions of lines of code worldwide.

2. Functional Interfaces

A Functional Interface is an interface that has exactly one abstract method. It can have multiple default or static methods, but only one method without a body. These interfaces are the targets for Lambda expressions.

While the @FunctionalInterface annotation is optional, it’s highly recommended as it tells the compiler to throw an error if you accidentally add a second abstract method.

3. The Core Functional Interfaces

Java 8 introduced the java.util.function package, which contains 40+ built-in functional interfaces. However, almost all of them are variations of these four giants:

A. Predicate (The Filter)

A Predicate takes one input and returns a boolean. It is primarily used for filtering data.

// Definition: boolean test(T t);
Predicate<Integer> isAdult = age -> age >= 18;

System.out.println(isAdult.test(20)); // true
System.out.println(isAdult.test(15)); // false

B. Consumer (The Action)

A Consumer takes one input and returns void (returns nothing). It “consumes” the data and performs an action, like printing or saving to a database.

// Definition: void accept(T t);
Consumer<String> printer = message -> System.out.println("Log: " + message);

printer.accept("User logged in"); // Output: Log: User logged in

C. Supplier (The Provider)

A Supplier takes no input and returns a value of type T. It is often used for lazy generation of data or providing default values.

// Definition: T get();
Supplier<Double> randomValue = () -> Math.random();

System.out.println(randomValue.get()); // Returns a random number

D. Function<T, R> (The Transformer)

A Function takes an input of type T and returns a result of type R. It is used to transform or map one value into another.

// Definition: R apply(T t);
Function<String, Integer> stringLength = s -> s.length();

System.out.println(stringLength.apply("Hello Java 8")); // Output: 12

Real-World Example: Data Pipeline

Let’s see all four working together in a simplified user processing flow:

public void processUser(String input) {
    // 1. Supplier: Provide a raw string if null (Provider)
    Supplier<String> rawData = () -> "Default_User";
    String data = (input != null) ? input : rawData.get();

    // 2. Predicate: Check if valid (Filter)
    Predicate<String> isValid = s -> s.length() > 5;

    // 3. Function: Transform to uppercase (Transformer)
    Function<String, String> transformer = String::toUpperCase;

    // 4. Consumer: Print the result (Action)
    Consumer<String> logger = System.out::println;

    if (isValid.test(data)) {
        String result = transformer.apply(data);
        logger.accept(result);
    }
}

Conclusion

Default methods and Functional Interfaces are the unsung heroes of Java 8. While Lambdas get all the fame, it’s these interface enhancements that provided the structural foundation. By mastering Predicate, Consumer, Supplier, and Function, you gain the ability to write highly flexible, reusable, and modern Java code.