Annotations & Processing

@Override tells the compiler a method is meant to replace one from a parent class or interface. If it doesn't actually match a parent method, you get a compile error. It catches typos and wrong signatures early.

You declare a custom annotation with the @interface keyword instead of interface. Inside, each method (with no body) becomes a configurable element you can set when you use the annotation, like @MyAnno(name = "x").

Extend AbstractProcessor, declare which annotations you handle with @SupportedAnnotationTypes and the Java version with @SupportedSourceVersion. Override process(), where RoundEnvironment.getElementsAnnotatedWith() gives you the annotated code to read and generate from.

An element's type can be a primitive, String, Class, an enum, another annotation, or a single-dimension array of those. You can't use arbitrary objects, collections like List, or nested arrays.

@Retention says how long an annotation is kept. SOURCE: discarded after compiling. CLASS (the default): stored in the .class file but not loaded at runtime. RUNTIME: kept and readable via reflection while the program runs.

@Retention says how long the annotation survives, SOURCE, CLASS, or RUNTIME. Only RUNTIME is readable by reflection. @Target restricts which code elements it can be placed on (method, field, type, etc.). Wrong choices mean your framework can't find it or it can't be applied where you need.

@Documented makes an annotation show up in the generated Javadoc of whatever it is applied to. To read an annotation's values while the program runs, you use reflection (getAnnotation) and call the annotation's element methods — but only if it is kept at RUNTIME.

The Filer creates new files: call filer.createSourceFile(name) and write Java text to it. JavaPoet is a library that builds the Java source for you with a typed API instead of string concatenation. For problems, use the Messager to print an ERROR tied to the offending element, which fails the build.

The compiler finds processors via the ServiceLoader file META-INF/services/javax.annotation.processing.Processor listing your class. Google AutoService generates that file for you. You can also name processors explicitly with javac's -processor flag, or disable processing with -proc:none.

@Deprecated marks code that should no longer be used. The compiler warns anyone who uses it. Since Java 9 you can add since="version" to say when it was deprecated and forRemoval=true to warn it will be deleted in a future release.

@FunctionalInterface marks an interface that has exactly one abstract method, so it can be used with lambdas. If you add a second abstract method, the code won't compile. It's optional — it just documents intent and guards the contract.

@SuppressWarnings tells the compiler to stop showing specific named warnings for the element it's on, like @SuppressWarnings("unchecked"). Apply it as narrowly as possible (one method or variable), not on a whole class, so you don't hide real problems.

Add 'default <value>' after an element to give it a default. Then you can leave that element out when using the annotation and it takes the default. Elements without a default must always be supplied.

If an element is named exactly 'value', you can set it without naming it: @Anno("x") means @Anno(value = "x"). It works only when value is the only element you need to supply.

@Target restricts which program elements an annotation can be placed on, like methods or fields, using ElementType values. With no @Target, the annotation can be used almost everywhere.

Element represents a declaration (a class, method, field), while TypeMirror represents a type (like List<String>). TypeElement is a class/interface, ExecutableElement a method, VariableElement a field/parameter. The Elements and Types helper objects answer questions about them, and visitors traverse them safely.

When a method takes a varargs of a generic type, the compiler warns it might not be type-safe because of how generics work. @SafeVarargs is you promising the method doesn't misuse that array, which removes the warning at the method and at every call site.

@Inherited makes a class-level annotation be seen on subclasses too, when you ask via reflection. It only works for annotations on classes — not on methods, fields, or interfaces.

@Repeatable (Java 8) lets you put the same annotation on one element multiple times. You also declare a 'container' annotation that holds an array of them; the compiler bundles the repeats into that container.

Annotation processing generates new code at compile time, so it's type-safe and adds no runtime cost. Lombok rewrites your existing classes by hacking the compiler's internals. Reflection inspects code at runtime, which is flexible but slower and less safe. Pick generation for boilerplate, reflection only when behavior must be dynamic.

Use a marker (no elements) when presence alone is the signal. Use a single value element when there's one obvious attribute (enables @Anno("x")). Use multiple elements with defaults for richer config. Give every non-primary element a default so you can add more later without breaking callers.