Understanding Java Annotations: Types, Usage, and Implementation

Java annotations, introduced in JDK 5, are a form of metadata that can be attached to program elements such as classes, methods, and fields, allowing tools and frameworks to process additional information at compile time or runtime.

Annotations serve several practical purposes: generating documentation, performing compile‑time checks (e.g., @Override), configuring frameworks (e.g., Spring), and enabling reflection‑based processing.

The article classifies annotations into three categories:

Standard annotations provided by the JDK (e.g., @Override, @Deprecated, @SuppressWarnings).

Meta‑annotations that define other annotations (e.g., @Retention, @Target, @Documented, @Inherited, @Repeatable).

Custom annotations defined by developers for specific needs.

Standard Annotations

class Parent { public void test() {} } class Child extends Parent { // Uncomment the following to see a compile‑time warning // @Override // public void test() {} }

The @Override annotation signals that a method overrides a superclass method; if it does not, the compiler issues a warning.

@Deprecated class TestClass { // ... }

@Deprecated marks a class or member as obsolete, indicating that it should no longer be used.

@SuppressWarnings("unchecked") public void addItems(String item) { List items = new ArrayList(); items.add(item); }

@SuppressWarnings can suppress specific compiler warnings (e.g., "unchecked", "rawtypes", or "all").

Meta‑Annotations

@Retention defines how long an annotation is retained (SOURCE, CLASS, or RUNTIME). Example:

@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Retention { RetentionPolicy value(); } public enum RetentionPolicy { SOURCE, CLASS, RUNTIME }

@Target specifies the program elements an annotation can be applied to (e.g., METHOD, FIELD, TYPE).

@Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) public @interface Override {} @Documented @Retention(RetentionPolicy.RUNTIME) public @interface Deprecated {} @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) @Retention(RetentionPolicy.SOURCE) public @interface SuppressWarnings { String[] value(); }

@Documented indicates that the annotation should be included in generated Javadoc.

@Inherited allows subclasses to inherit annotations from their superclasses.

@Inherited public @interface Greeting { enum FontColor { BLUE, RED, GREEN } String name(); FontColor fontColor() default FontColor.GREEN; }

@Repeatable enables an annotation to be applied multiple times on the same element.

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Repeatable(Schedules.class) public @interface Scheduled { // ... } public @interface Schedules { Scheduled[] value(); }

Custom Annotations

Developers can define their own annotations similarly to interfaces, using meta‑annotations to control retention and target.

@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Inherited public @interface HelloAnnotation { String value(); }

Creating a custom annotation involves declaring it with the @interface keyword and optionally providing methods that act as annotation attributes.