Annotations are a form of metadata that provide data about a program but are not part of the program itself. Annotations have no direct effect on the operation of the code they annotate but can be used by the compiler or at runtime through reflection.

@AnnotationName(value)
Example:

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

Built-in Java Annotations

• @Override: Indicates that a method overrides a method in a superclass.
• @Deprecated: Marks a method or class as deprecated, warning users not to use it.
• @SuppressWarnings: Tells the compiler to suppress specific warnings.
• @FunctionalInterface: Indicates an interface with exactly one abstract method.
• @SafeVarargs: Suppresses warnings for using varargs with generics.

Meta-annotations are annotations that apply to other annotations.
• @Retention(RetentionPolicy.RUNTIME) – Retained at runtime, available to the JVM.
• @Target(ElementType.METHOD) – Applied only to methods.
• @Documented – Appears in the Javadoc.
• @Inherited – Allows a subclass to inherit an annotation from the superclass.

You can create your own annotations in Java.

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

Usage:

@MyAnnotation(value = "test")
public void myMethod() {
    // method body
}

Java Reflection is a feature that allows inspection and manipulation of classes, methods, and fields at runtime, regardless of their access modifiers.

Key Classes in java.lang.reflect

• Class: Represents classes and interfaces.
• Method: Represents class methods.
• Field: Represents class fields.
• Constructor: Represents class constructors.
• Modifier: Provides information about class modifiers.

Class clazz = Class.forName("com.example.MyClass");

Alternative ways:

MyClass obj = new MyClass();
Class clazz = obj.getClass();
Class clazz = MyClass.class;

public class Sample {
    private int id;
    public String name;
    public void display() {
        System.out.println("Display");
    }
}

Reflection:

Class clazz = Sample.class;
System.out.println("Fields:");
for (Field field : clazz.getDeclaredFields()) {
    System.out.println(field.getName());
}
System.out.println("Methods:");
for (Method method : clazz.getDeclaredMethods()) {
    System.out.println(method.getName());
}

Class clazz = Class.forName("Sample");
Object obj = clazz.getDeclaredConstructor().newInstance();

Field field = clazz.getDeclaredField("id");
field.setAccessible(true);
field.set(obj, 101);
System.out.println(field.get(obj));

Reflection is often used to read and process annotations at runtime.

public class Processor {
    @MyAnnotation(value = "run")
    public void execute() {
        System.out.println("Executing...");
    }
}

Processor:

Class clazz = Processor.class;
for (Method method : clazz.getDeclaredMethods()) {
    if (method.isAnnotationPresent(MyAnnotation.class)) {
        MyAnnotation anno = method.getAnnotation(MyAnnotation.class);
        System.out.println("Annotation value: " + anno.value());
        method.invoke(clazz.getDeclaredConstructor().newInstance());
    }
}

Use Cases of Annotations and Reflection

Annotations
- Framework development (Spring, JUnit)
- Declarative configuration
- Code generation
- Compiler instructions

Reflection
- Dependency injection
- Testing frameworks
- Serializers/Deserializers
- Runtime analysis tools (e.g., debuggers, profilers)

Limitations and Considerations

• Performance Overhead: Reflection is slower than direct code.
• Security: May expose private fields/methods.
• Complexity: Makes code harder to understand and maintain.
• No Compile-time Checking: Can lead to runtime exceptions.

In this chapter, we explored two powerful Java features:
- Annotations, which are metadata tools enabling configuration and information sharing.
- Reflection API, which allows dynamic inspection and manipulation of code at runtime.
Together, they form the foundation for many modern frameworks and dynamic applications. Understanding these tools enables developers to build flexible, reusable, and extensible software.