What are Functional Interfaces in Java?

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Declare one abstract method

   Define an interface with a single abstract method (the SAM), which makes it functional.

2. Step 2

   Add @FunctionalInterface

   Optionally annotate it so the compiler enforces exactly one abstract method.

3. Step 3

   Include defaults if needed

   Add default or static methods freely — they do not count against the single-method rule.

4. Step 4

   Implement with a lambda

   Provide the behavior with a lambda expression or a method reference instead of an anonymous class.

5. Step 5

   Reuse built-ins

   Prefer java.util.function types like Predicate, Function, Consumer, and Supplier when they fit.

Code Example

import java.util.function.Predicate;

@FunctionalInterface
interface Calculator {
    int operate(int a, int b); // single abstract method

    default void log() {        // default method allowed
        System.out.println("Calculating...");
    }
}

public class FunctionalDemo {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;   // lambda implements the SAM
        System.out.println(add.operate(3, 4)); // 7

        Predicate<Integer> isEven = n -> n % 2 == 0; // built-in
        System.out.println(isEven.test(10)); // true
    }
}

Follow-up Questions

• Name the four core functional interfaces in java.util.function.
• Can a functional interface have default and static methods?
• Is the @FunctionalInterface annotation required to use lambdas?
• What is the difference between Function and BiFunction?
• How does a method reference relate to a functional interface?