Java Annotations – Built-in and Custom Annotations

Java Annotations are a powerful feature that provide metadata about a program. They are widely used in modern Java frameworks such as Spring, Hibernate, and testing frameworks. Annotations help developers add additional information to classes, methods, fields, and parameters without changing the actual business logic.

Understanding built-in and custom annotations is important for developers who want to work with advanced Java applications and frameworks.

---

What are Java Annotations?

Annotations are metadata added to Java code that provide information to the compiler or runtime environment.

Annotations do not directly affect program execution but can influence how programs are processed by tools and frameworks.

Example:

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

Here, @Override is an annotation that tells the compiler that the method overrides a method from the parent class.

---

Why Are Annotations Used?

Annotations provide several advantages:

• Improve code readability

• Reduce configuration using XML files

• Provide additional information to frameworks

• Enable compile-time and runtime processing

• Simplify framework development

---

Built-in Java Annotations

Java provides several built-in annotations commonly used in development.

@Override

This annotation indicates that a method overrides a method in the superclass.

Example:

@Override
public void display() {
    System.out.println("Display Method");
}

It helps the compiler check whether the method correctly overrides a parent class method.

---

@Deprecated

The @Deprecated annotation indicates that a method or class is no longer recommended for use.

Example:

@Deprecated
public void oldMethod() {
}

When developers use this method, the compiler shows a warning.

---

@SuppressWarnings

This annotation is used to suppress compiler warnings.

Example:

@SuppressWarnings("unchecked")
List list = new ArrayList();

This prevents unnecessary compiler warnings during compilation.

---

@FunctionalInterface

This annotation is used in Java 8 to indicate that an interface contains only one abstract method.

Example:

@FunctionalInterface
interface MyInterface {
    void show();
}

It is commonly used with Lambda Expressions.

---

What Are Custom Annotations?

Java also allows developers to create their own annotations. These are called Custom Annotations.

Custom annotations are useful when building:

• Frameworks

• Validation tools

• Logging systems

• Configuration-based applications

---

Creating a Custom Annotation

Custom annotations are created using the @interface keyword.

Example:

@interface Author {
    String name();
    int version();
}

This creates a custom annotation called Author.

---

Using Custom Annotation

After creating an annotation, it can be used like this:

@Author(name="Harish", version=1)
class MyClass {
}

This attaches metadata to the class.

---

Retention Policies

Annotations can be retained at different stages using RetentionPolicy.

• SOURCE – Available only in source code

• CLASS – Stored in the class file

• RUNTIME – Available during runtime using reflection

Example:

@Retention(RetentionPolicy.RUNTIME)
@interface Author {
    String name();
}

---

Target Annotations

The @Target annotation defines where an annotation can be applied.

Possible targets include:

• TYPE (class, interface)

• METHOD

• FIELD

• CONSTRUCTOR

• PARAMETER

Example:

@Target(ElementType.METHOD)
@interface TestAnnotation {
}

---

Real-World Usage of Annotations

Annotations are heavily used in modern Java frameworks.

Examples include:

• Spring Framework – @Component, @Autowired, @Service

• Spring Boot – @SpringBootApplication

• Hibernate – @Entity, @Table

• JUnit – @Test

These annotations help reduce configuration and simplify development.

---

Conclusion

Java Annotations provide a powerful way to add metadata to Java programs. Built-in annotations help improve code quality and readability, while custom annotations allow developers to create flexible and dynamic applications.

Understanding annotations is essential for developers working with modern frameworks such as Spring and Hibernate.

If you want to learn Java from the basics to advanced concepts with practical examples, joining Core JAVA Online Training can help you build strong programming skills and prepare for real-world development.