Annotations in Java

In Java, annotations are a powerful mechanism for attaching additional information (metadata) to program elements like classes, methods, fields, and packages. This metadata can be processed by various tools during compilation, deployment, or even runtime, leading to enriched functionality and improved code maintainability.

Key Characteristics:

Syntax: Annotations start with the @ symbol followed by the annotation type name. They are typically placed on separate lines above the element they annotate.

No Code Generation: Annotations don't directly alter the compiled code's behavior. They provide supplementary information that tools can leverage.

Retention: Annotations can be retained at different stages of the Java development process:
  1. Source Level Only: Not retained in class files (e.g., @SuppressWarnings).
  2. Source and Class Level: Retained in class files but not accessible at runtime (e.g., @Override).
  3. Source, Class, and Runtime: Retained in class files and accessible at runtime using reflection (e.g., @Deprecated).

Built-in Annotations in Java:

The Java platform provides a set of predefined annotations:

  1. @Override: Ensures a method is correctly overriding a parent class method.
  2. @Deprecated: Marks a method or class as outdated, prompting warnings when used.
  3. @SuppressWarnings: Suppresses specific compiler warnings for designated code sections.
  4. @FunctionalInterface: Enforces that a declared interface can have only one abstract method.
  5. @SafeVarargs: Indicates a method is safe to use with variable arguments (varargs).
  6. @Documented: Marks an annotation type to be included in Javadoc.
  7. @Retention: Specifies the retention policy (source, class, or runtime) of an annotation.


@Override: Indicates that a method is intended to override a method in a superclass. This annotation helps ensure that you are actually overriding a method and not inadvertently creating a new method with a similar name.
class Parent { public void display() { System.out.println("Parent display"); } } class Child extends Parent { @Override public void display() { System.out.println("Child display"); } }
@Deprecated: Marks a method or class as deprecated, indicating that it should no longer be used because it is obsolete or will be removed in future versions.
class DeprecatedExample { @Deprecated public void oldMethod() { System.out.println("This method is deprecated."); } }
@SuppressWarnings: Suppresses warnings for specific code snippets. It can be used to suppress compiler warnings that are not meaningful or necessary.
class SuppressWarningExample { @SuppressWarnings("unchecked") public void uncheckedMethod() { ArrayList list = new ArrayList(); list.add("Unchecked"); } }

Custom Annotations

Developers can define their own annotations for specific use cases.

Creating a Custom Annotation:
import java.lang.annotation.*; @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface MyCustomAnnotation { String value(); }
Using Custom Annotation:
class CustomAnnotationExample { @MyCustomAnnotation("This is a custom annotation") public void myMethod() { // Method implementation } }
Processing Custom Annotations:
  1. Reflection: At runtime, use reflection to access information from annotations applied to program elements.
  2. Annotation Processors (Java SE 5 and later): Special classes can be written to process annotations during compilation, enabling code generation, validation, or other tasks.

Framework Annotations:

Frameworks often define their own annotations to configure or extend their functionality.

Spring Framework:

@Controller, @Service, @Repository: Annotations used for component scanning and dependency injection in Spring. @Controller public class MyController { // Controller methods }

JPA (Java Persistence API):

@Entity, @Table, @Column: Annotations used for defining database entities, tables, and columns.

@Entity @Table(name = "employees") public class Employee { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "name") private String name; }

Benefits of Using Annotations

  1. Improved Code Readability: Annotations enhance documentation by capturing essential details directly within the code.
  2. Enhanced Compiler and Tooling Support: Tools can process annotations to perform tasks like code generation, framework configuration, validation, and more.
  3. Increased Modularity and Reusability: Annotations can guide frameworks and libraries in processing components consistently.


Java annotations offer a valuable approach to enrich your code with metadata, leading to clearer code, better tooling support, and enhanced maintainability. By effectively combining built-in annotations with custom ones, you can create more flexible and informative Java programs.