All 15 Annotations questions
More in Annotations
How do you apply multiple different annotations to the same element, and does their order matter? How do you create a custom annotation in Java, and what role do @Retention and @Target play? What is the difference between compile-time annotation processing (via javax.annotation.processing.Processor) and runtime reflection-based annotation reading? What are Java's meta-annotations (@Retention, @Target, @Documented, @Inherited), and what does each control? How do annotations with elements (parameters) work, including default values and the special `value` element? What is the difference between the @Nullable/@NonNull annotations (from libraries like JetBrains or JSR-305) and Java's built-in Optional type for expressing nullability? How would you read custom annotations at runtime using reflection to implement annotation-driven behavior, such as a simple dependency injection or validation framework? How do repeatable annotations work in Java (using @Repeatable), and what problem do they solve? How would you implement annotation-based validation (similar to Bean Validation's @NotNull, @Size) using a custom annotation and a reflection-based validator? How does Java's annotation processing API (javax.annotation.processing) enable compile-time code generation frameworks like Lombok or Dagger, and what are its key limitations?
Advertisement
Java › Annotations

What is the purpose of the @FunctionalInterface annotation, and is it required for an interface to actually be treated as a functional interface?

Intermediate

Answer

@FunctionalInterface is a marker/documentation annotation that instructs the compiler to verify the annotated interface has exactly one abstract method (making it eligible for lambda expression assignment) -- it's not strictly required for an interface with a single abstract method to work as a functional interface (the compiler infers this structurally regardless), but omitting it removes the safety net where the compiler would otherwise immediately flag an accidental second abstract method being added later, which would silently break lambda compatibility.
@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
    // Adding a second abstract method here would now cause a COMPILE ERROR, not a runtime surprise
}

Calculator add = (a, b) -> a + b;
Real-world example A shared library interface is marked @FunctionalInterface specifically so that if a future contributor accidentally adds a second abstract method (breaking every lambda-based usage across dozens of consumers), the compiler catches this immediately at the library's own build time rather than the error surfacing confusingly at each consumer's build.

Common follow-ups: What happens if you apply @FunctionalInterface to an interface with two abstract methods?;How do default and static methods interact with the single-abstract-method requirement?

Functional Interfaces & Method References;Interfaces & Abstract Classes
All 15 Annotations questions