What are annotations in Java?

Annotations in Java are a form of metadata that can be added to Java source code. They provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate, but tools and libraries can interpret and act upon them. They are primarily used to provide information to the compiler, build tools, and runtime environment.

What are Annotations?

Annotations provide a declarative way to add metadata to Java code, allowing developers to embed supplementary information directly within their source files. This metadata can then be processed by various tools during compilation, deployment, or even at runtime via reflection. Annotations do not change the execution of a program directly, but they guide how the program is handled by other components.

Common Built-in Annotations

• <code>@Override</code>: Indicates that a method declaration is intended to override a method declaration in a supertype. The compiler checks if the method actually overrides one.
• <code>@Deprecated</code>: Marks a program element (class, method, field) as obsolete and warns about its use. The compiler can issue a warning if deprecated elements are used.
• <code>@SuppressWarnings</code>: Suppresses specific compiler warnings for the annotated element.
• <code>@FunctionalInterface</code>: Indicates that an interface type declaration is intended to be a functional interface, which means it has exactly one abstract method. The compiler enforces this contract.
• <code>@SafeVarargs</code>: Applied to methods or constructors with varargs parameters to assert that they do not perform unsafe operations on the varargs parameter. Suppresses compiler warnings related to potential heap pollution.

Custom Annotations

Developers can define their own custom annotations to provide specific metadata relevant to their application domain or framework. Custom annotations are declared using the <code>@interface</code> keyword. They can have elements (methods) that look like parameters, which can be assigned values when the annotation is used.

public @interface MyCustomAnnotation {
    String value() default "Default Value";
    int count() default 0;
    String[] tags();
}

Usage example of the custom annotation:

@MyCustomAnnotation(value = "Important Info", count = 10, tags = {"api", "config"})
public class MyService {
    // ...
}

Meta-Annotations

Meta-annotations are annotations that annotate other annotations. They are used to specify how a custom annotation itself should be treated by the compiler or JVM. Key meta-annotations include:

• <code>@Target</code>: Specifies the contexts in which the annotation is applicable (e.g., classes, methods, fields).
• <code>@Retention</code>: Indicates how long the annotation should be retained (e.g., source file only, compiled class file, or at runtime).
• <code>@Inherited</code>: Indicates that an annotation type is automatically inherited by subclasses.
• <code>@Documented</code>: Indicates that annotations with this type are to be documented by Javadoc and similar tools.

import java.lang.annotation.*;

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

Where Annotations Are Used

• Compiler Instructions: Providing warnings, errors, or suppression of warnings (e.g., <code>@Override</code>, <code>@SuppressWarnings</code>).
• Build-time Processing: Tools like Lombok use annotations to generate boilerplate code during the build process.
• Runtime Processing (Reflection): Frameworks like Spring, Hibernate, and JUnit extensively use annotations to configure components, define mappings, and manage execution flow by reading annotation metadata at runtime.

Annotations have become a fundamental part of modern Java development, simplifying configuration, reducing boilerplate code, and enabling powerful declarative programming paradigms in various frameworks and libraries.