What is a Functional Interface?

Think of it as a one-job tool: interviewers ask this because it is the doorway to lambdas, method references, and cleaner Java 8 code.

Question: What is a Functional Interface?

Answer: A functional interface is an interface that has exactly one abstract method, so it represents one behavior or action. It can still have default methods, static methods, and in newer Java versions private helper methods, because those do not count toward the single abstract method rule. In Java 8, functional interfaces are the target type for lambda expressions and method references.

Interview-Ready Answer: A functional interface is an interface with exactly one abstract method, often called a SAM interface, which stands for Single Abstract Method. I use it when I want to pass behavior into a method, especially with lambdas or method references in Java 8. The best-known examples are `Runnable`, `Callable`, `Predicate`, `Function`, and `Consumer`. The `@FunctionalInterface` annotation is optional, but I like it because it makes the compiler enforce the rule for me.

What it is

Detailed Explanation: A functional interface is a contract for behavior, not for data. It says, in simple terms, here is one operation you must provide. That one operation can be implemented with a lambda, an anonymous class, or a method reference. The key idea is that Java can treat the interface like a type for a piece of behavior.

How it works under the hood

1. You declare an interface with one abstract method. The method name can be anything; it does not have to be `apply`.
2. The compiler checks that there is exactly one abstract method, excluding methods inherited from `Object` such as `toString`, `equals`, and `hashCode`.
3. When you assign a lambda to that type, Java uses the interface as the target type — meaning the compiler knows the parameter types and return type from the interface.
4. The lambda body is linked to the interface method. On modern JVMs, this is usually done with `invokedynamic` and `LambdaMetafactory`, which help create the implementation efficiently at runtime.
5. If the lambda captures local variables, those variables must be final or effectively final, meaning they are not reassigned after initialization. Java copies the captured values into the generated object.
6. When you call the method, it runs like a normal method call. There is no magic thread, queue, or scheduler involved.

What is allowed

• Allowed: one abstract method.
• Allowed: any number of default methods, static methods, and helper methods that do not add more abstract behavior.
• Allowed: the `@FunctionalInterface` annotation, which is optional but useful because it makes the compiler verify your intent.
• Allowed: interfaces that extend other interfaces, as long as the final count of abstract methods is still one.

What is not allowed

• Two real abstract methods means it is no longer a functional interface.
• If you accidentally add a second abstract method later, every lambda using that interface stops compiling.
• A method like `equals(Object)` does not usually break the rule because methods from `Object` are not counted as the interface’s functional method.

Comparison with nearby ideas

When and why to use it

• Use it when a method needs to accept a small piece of behavior, like filtering, transforming, or handling an event.
• It makes code shorter and easier to read than a full anonymous class.
• It fits naturally with streams, where `Predicate`, `Function`, `Consumer`, and `Supplier` are used constantly.
• It also works well for strategy patterns, where you swap one rule or algorithm for another at runtime.

Performance and practical notes

• Defining a functional interface is a compile-time concept; the cost is basically zero at runtime.
• Invoking the method is normally as cheap as a regular virtual method call after JIT optimization.
• If a lambda captures state, the generated object stores that captured state, so memory cost grows with the captured values, not with the number of methods.
• Java 8 introduced lambdas and functional interfaces. Java 9 later added private interface methods, which are helper methods and still do not affect the one-abstract-method rule.

Memory hook

One job, one button: if an interface has one real job, Java can turn it into a lambda.

Real-World Example: Imagine a checkout service in an e-commerce app. The team has a pricing pipeline where one rule checks coupon eligibility, another applies a discount, and another blocks suspicious carts. Each rule is passed around as a functional interface like `Predicate<Cart>` or `Function<Cart, Price>`, so the checkout flow can swap rules without rewriting the pipeline.

Now picture a bad change: a developer thinks the interface should also expose a debug label, so they add a second abstract method. Suddenly every lambda-based rule in the service stops compiling, CI turns red, and the release for a big weekend promotion is delayed. The compiler message points right at the issue, but the business impact is visible immediately: marketing cannot launch the coupon campaign, support gets tickets saying discount application is temporarily unavailable, and the team scrambles to separate metadata from behavior.

The lesson is simple: keep the functional interface focused on one job only. Put extra metadata in another class or enum, not in the SAM itself.

Follow-up & Tricky Questions:

• What does `@FunctionalInterface` do? It tells the compiler to enforce the one-abstract-method rule. It is optional, but it prevents accidental breakage when someone later adds another abstract method.
• Can a functional interface have default methods? Yes. Default methods provide shared behavior and do not count as abstract methods, so they are perfectly valid.
• Can it have static methods? Yes. Static methods belong to the interface itself and are not part of the instance contract, so they do not affect the SAM rule.
• Why are lambdas tied to functional interfaces? Because Java needs a target type to know what parameters and return type the lambda should have. The interface supplies that shape.
• Can a functional interface extend another interface? Yes, as long as the final result still has exactly one abstract method. Multiple inherited abstract methods will break the rule.
• Is `Runnable` a functional interface? Yes, because it has one abstract method, `run()`. That is why you can pass `() -> { ... }` anywhere a `Runnable` is expected.
• Tricky: Does `equals(Object)` count as an abstract method in a functional interface? Usually no. Methods from `Object` are not counted toward the single abstract method rule, which surprises many candidates.
• Tricky: If a functional interface has zero abstract methods because everything is default, is it still functional? No. It must have exactly one abstract method, not zero.
• Tricky: Does a method reference create a new kind of interface? No. A method reference is just another way to supply an implementation to an existing functional interface.

Common Mistakes:

• Thinking any interface with helper methods is non-functional. Correction: default and static methods are fine; only extra abstract methods break it.
• Forgetting that `@FunctionalInterface` is optional. Correction: the annotation is not required for lambdas to work, but it is useful for compile-time safety.
• Believing the method name must be `apply`. Correction: the name can be anything; `apply` is just common in `Function`.
• Adding metadata to the SAM itself. Correction: keep the functional method focused on behavior and put extra fields or labels in a separate type.

Memory Hook: One job, one button. If the interface has one real job, it can be powered by a lambda.

Cheat Sheet:

• Functional interface = exactly one abstract method.
• `@FunctionalInterface` is optional but recommended.
• Default and static methods do not break it.
• Used by lambdas and method references in Java 8.
• Common examples: `Runnable`, `Predicate`, `Function`, `Consumer`, `Supplier`.
• Captured local variables must be final or effectively final.

Practice Tasks:

• Write your own `@FunctionalInterface` named `MathOperation` with one method and use two lambdas to add and multiply numbers.
• Take a `List<String>` and use `Predicate<String>` to filter blank values, then replace the lambda with a method reference where possible.
• Add a default method to your interface that combines two operations, and prove it still remains a functional interface.