Java Annotations

Java Annotations are metadata (extra information) added to code such as classes, methods, or variables.

They do not change the actual program logic, but they provide important instructions to the compiler, tools, and runtime environment about how the code should behave.

Annotations are widely used in modern Java applications, especially in frameworks, to make code more clean, structured, and easier to manage.

In simple words: Annotations help developers write cleaner, safer, and more maintainable code by adding extra information without modifying the logic.

---

Built-in Annotations

Java provides some predefined annotations that are commonly used in development. These annotations help the compiler understand your code better and also reduce common programming mistakes.

1. @Override

The @Override annotation is used when a method overrides a method from its parent class. It tells the compiler that this method is intended to override an existing method.

class Animal {
    void sound() {}
}

class Dog extends Animal {
    @Override
    void sound() {}
}

Benefits:

• @Override ensures that the method is actually overriding a method from the parent class
• If the method name or signature is wrong, the compiler will show an error
• It helps developers avoid accidental mistakes

---

2. @Deprecated

The @Deprecated annotation is used to mark a method or class as old or not recommended for use. It indicates that this element may be removed in future versions.

@Deprecated
void oldMethod() {}

here,

• @Deprecated tells developers that the method or class should no longer be used.
• It is usually applied when a better alternative is available.
• Helps maintain backward compatibility while guiding developers toward updated code.

---

3. @SuppressWarnings

The @SuppressWarnings annotation is used to ignore specific compiler warnings in your code.

@SuppressWarnings("unchecked")
void demo() {}

here,

• @SuppressWarnings("unchecked") tells the compiler to ignore unchecked warnings.
• It is commonly used when working with collections or legacy code.
• Helps keep the code clean by removing unnecessary warning messages.

---

Custom Annotations

Java allows you to create your own annotations, which can be used to add custom metadata to your code.

Example:

@interface Info {
    String author();
}

Usage:

@Info(author = "Amit")
class Test {}

here,

• @interface is used to define a custom annotation.
• String author(); defines an element (property) inside the annotation.
• @Info(author = "Amit") is how the annotation is applied to a class.

---

Retention Policies

Retention policy defines how long an annotation is available in the program lifecycle.

1. SOURCE

• Available only in source code
• Removed after compilation

Example:

import java.lang.annotation.*;

@Retention(RetentionPolicy.SOURCE)
@interface Info {}

@Info
class Test {}

? This annotation is not present in the compiled .class file.

2. CLASS

• Stored in .class file
• Not available at runtime

Example:

import java.lang.annotation.*;

@Retention(RetentionPolicy.CLASS)
@interface Info {}

@Info
class Test {}

? This annotation is available in the compiled class file, but cannot be accessed using Reflection.

3. RUNTIME

• Available at runtime
• Used with Reflection API

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@interface Info {}

Example with Reflection:

@Info
class Test {}

public class Main {
    public static void main(String[] args) {
        Info info = Test.class.getAnnotation(Info.class);
        System.out.println(info);
    }
}

? This annotation can be accessed at runtime using Reflection, which makes it the most important type.

---

Conclusion

Java Annotations play an important role in modern Java development by making code more structured and easier to manage.

• They help in writing cleaner and more organized code.
• Reduce boilerplate code by providing built-in metadata support.
• Improve code readability and maintainability.
• Widely used in frameworks like Spring and Hibernate.