All 15 Annotations questions
More in Annotations
What do the built-in @Override, @Deprecated, and @SuppressWarnings annotations do? 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 is the purpose of the @FunctionalInterface annotation, and is it required for an interface to actually be treated as a functional interface? 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?
Advertisement
Java › Annotations

What are Java's meta-annotations (@Retention, @Target, @Documented, @Inherited), and what does each control?

Intermediate

Answer

@Retention controls how long the annotation persists (SOURCE/CLASS/RUNTIME); @Target restricts which element types it can be applied to; @Documented causes the annotation to appear in generated Javadoc for annotated elements; @Inherited allows a class-level annotation to be automatically inherited by subclasses (only applies to annotations on classes, not methods/fields), letting a subclass be treated as if it also carries the annotation without redeclaring it.
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@Documented
public @interface Auditable { }

@Auditable
public class BaseEntity { }

public class Order extends BaseEntity { }  // inherits @Auditable automatically via reflection checks
Real-world example An auditing framework marks a base entity class with a custom @Inherited @Auditable annotation, and reflection-based checks on any subclass (like Order extends BaseEntity) correctly detect the annotation as present even though Order itself never explicitly declares it.

Common follow-ups: Why does @Inherited only work for class-level annotations, not methods or fields?;What's a scenario where you'd deliberately choose CLASS retention instead of RUNTIME or SOURCE?

Reflection API;OOP & Classes
All 15 Annotations questions