Annotations

@Override
public String toString() {
    return "MyObject";
}

@Deprecated
public void oldMethod() { }

@SuppressWarnings("unchecked")
public void legacyCode() { }

Common follow-ups: What's the difference between a marker annotation (no elements) and one with elements?;How does the compiler use @Override to catch a common class of bugs?

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Loggable {
    String value() default "";
}

public class Service {
    @Loggable("critical operation")
    public void process() { }
}

Common follow-ups: What happens if you try to apply an annotation to an element type not listed in @Target?;Why would you ever choose SOURCE or CLASS retention over RUNTIME?

public class AnnotationProcessor {
    public static void invokeLoggable(Object obj) throws Exception {
        for (Method method : obj.getClass().getDeclaredMethods()) {
            if (method.isAnnotationPresent(Loggable.class)) {
                Loggable ann = method.getAnnotation(Loggable.class);
                System.out.println("Invoking logged method: " + ann.value());
                method.invoke(obj);
            }
        }
    }
}

Common follow-ups: What's the performance cost of reflection-based annotation processing at runtime versus compile-time annotation processing?;How does Java's annotation processing API (APT) differ from reading annotations reflectively at runtime?

@SupportedAnnotationTypes("com.example.GenerateBuilder")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class BuilderProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // generates new .java source files at compile time
        return true;
    }
}

Common follow-ups: Why do frameworks like Dagger prefer compile-time code generation over Spring's runtime reflection-based approach?;What are the debugging challenges specific to compile-time generated code?

public class Base {
    public void process() { }
}

public class Derived extends Base {
    @Override
    public void proccess() { }  // typo! Compiler catches this because @Override expects an actual override
}

Common follow-ups: What happens if you omit @Override but still intend to override a method -- does the code still work?;When is it appropriate to use @SuppressWarnings versus actually fixing the underlying warning?

@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Schedules.class)
public @interface Schedule {
    String day();
}

@Retention(RetentionPolicy.RUNTIME)
public @interface Schedules {
    Schedule[] value();
}

public class Job {
    @Schedule(day = "MONDAY")
    @Schedule(day = "FRIDAY")
    public void run() { }
}

Common follow-ups: What does the generated container annotation (@Schedules) look like if you don't use @Repeatable and must retrieve multiple annotations manually?;How does getAnnotationsByType() differ from getAnnotation() when reading repeatable annotations?

@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

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?

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MinLength {
    int value();
}

public class Validator {
    public static List<String> validate(Object obj) throws Exception {
        List<String> errors = new ArrayList<>();
        for (Field field : obj.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(MinLength.class)) {
                field.setAccessible(true);
                String value = (String) field.get(obj);
                int min = field.getAnnotation(MinLength.class).value();
                if (value == null || value.length() < min) {
                    errors.add(field.getName() + " must be at least " + min + " characters");
                }
            }
        }
        return errors;
    }
}

Common follow-ups: What are the performance implications of using field.setAccessible(true) and reflective field access at scale?;How does this reflection-based approach compare to a compile-time annotation processor generating validation code instead?

@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;

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?

@SupportedAnnotationTypes("com.example.AutoValue")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class AutoValueProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(AutoValue.class)) {
            // generates a NEW source file implementing the value class, via processingEnv.getFiler()
        }
        return true;
    }
}

Common follow-ups: Why can't a standard annotation processor modify the source file it's processing?;What alternative approaches exist for frameworks that need to modify existing classes, like AspectJ's compile-time weaving?