Annotations in Java

Annotations in Java are a form of metadata that provide additional information about the program. They do not change the action of a compiled program but can be used by the compiler or runtime for processing.

Key Points

• Annotations start with ‘@’.
• Annotations do not change the action of a compiled program.
• Annotations help to associate metadata (information) to the program elements i.e. instance variables, constructors, methods, classes, etc.
• Annotations are not pure comments as they can change the way a program is treated by the compiler. See below code for example.
• Annotations basically are used to provide additional information, so could be an alternative to XML and Java marker interfaces.

Hierarchy of Annotations in Java 

Categories of Annotations

There are broadly 5 categories of annotations as listed:

1. Marker Annotations
2. Single value Annotations
3. Full Annotations
4. Type Annotations
5. Repeating Annotations

Let us discuss and we will be appending code wherever required if so. 

1. Marker Annotations

• Do not have any elements or values (just presence is enough).
• Used to signal the compiler or tools with metadata.

Example

@TestAnnotation()

2. Single value Annotations 

• Contain only one element (can use shorthand notation).
• When specifying value, you don’t need to write the element name.

Example

@TestAnnotation(“testing”);

3. Full Annotations 

• Contain multiple elements as key-value pairs.
• All values must be provided unless defaults are defined.

Example

@TestAnnotation(owner=”Rahul”, value=”Class Geeks”)

4. Type Annotations 

• Introduced in Java 8 for annotating types (variables, generics, return types).
• Useful for stronger type checking and frameworks.
• Declared with @Target(ElementType.TYPE_USE)

Example: Java Program to Demonstrate Type Annotation

 import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

// Using target annotation to annotate a type
@Target(ElementType.TYPE_USE)

// Declaring a simple type annotation
@interface TypeAnnoDemo{}

// Main class 
public class GFG {
  
    // Main driver method 
    public static void main(String[] args) {

        // Annotating the type of a string
        @TypeAnnoDemo String string = "I am annotated with a type annotation";
        System.out.println(string);
        abc();
    }

    // Annotating return type of a function
    static @TypeAnnoDemo int abc() {
      
        System.out.println("This function's  return type is annotated");
      
        return 0;
    }
}

I am annotated with a type annotation
This function's  return type is annotated

5. Repeating Annotations 

• Allow the same annotation to be applied multiple times on a single element.
• Declared using @Repeatable with a container annotation.
• Example: @Schedule(day="Monday") @Schedule(day="Tuesday").

Example: Java Program to Demonstrate a Repeatable Annotation

import java.lang.annotation.Annotation;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;

// Make Words annotation repeatable
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(MyRepeatedAnnos.class)
@interface Words
{
    String word() default "Hello";
    int value() default 0;
}

// Create container annotation
@Retention(RetentionPolicy.RUNTIME)
@interface MyRepeatedAnnos
{
    Words[] value();
}
public class Main {

    // Repeat Words on newMethod
    @Words(word = "First", value = 1)
    @Words(word = "Second", value = 2)
    public static void newMethod()
    {
        Main obj = new Main();

        try {
            Class<?> c = obj.getClass();

            // Obtain the annotation for newMethod
            Method m = c.getMethod("newMethod");

            // Display the repeated annotation
            Annotation anno
                = m.getAnnotation(MyRepeatedAnnos.class);
            System.out.println(anno);
        }
        catch (NoSuchMethodException e) {
            System.out.println(e);
        }
    }
    public static void main(String[] args) { newMethod(); }
}

@MyRepeatedAnnos({@Words(value=1, word="First"), @Words(value=2, word="Second")})

Standard (Predefined) Annotations

Java provides seven built-in annotations.

From java.lang

1. @Deprecated 

• It is a marker annotation. It indicates that a declaration is obsolete and has been replaced by a newer form.
• The Javadoc @deprecated tag should be used when an element has been deprecated.
• @deprecated tag is for documentation and @Deprecated annotation is for runtime reflection.
• @deprecated tag has higher priority than @Deprecated annotation when both are together used.

Example:

public class DeprecatedTest
{
    @Deprecated
    public void Display()
    {
        System.out.println("Deprecatedtest display()");
    }

    public static void main(String args[])
    {
        DeprecatedTest d1 = new DeprecatedTest();
        d1.Display();
    }
}

Deprecatedtest display()

2. @Override

• It is a marker annotation that can be used only on methods.
• Ensures that a method actually overrides a method from its superclass.
• Helps catch errors when method signatures don’t match.

Example: Java Program to Illustrate Override Annotation

class Base
{
     public void Display()
     {
         System.out.println("Base display()");
     }
     
     public static void main(String args[])
     {
         Base t1 = new Derived();
         t1.Display();
     }     
}

// Class 2
// Extending above class 
class Derived extends Base
{
     @Override
     public void Display()
     {
         System.out.println("Derived display()");
     }
}

Derived display()

3. @SuppressWarnings 

• Suppresses specific compiler warnings (e.g., unchecked, deprecation).
• Useful to make code cleaner without unnecessary warning messages.

Example: Java Program to illustrate SuppressWarnings Annotation

class DeprecatedTest
{
    @Deprecated
    public void Display()
    {
        System.out.println("Deprecatedtest display()");
    }
}

public class SuppressWarningTest
{
    // If we comment below annotation, program generates
    // warning
    @SuppressWarnings({"checked", "deprecation"})
    public static void main(String args[])
    {
        DeprecatedTest d1 = new DeprecatedTest();
        d1.Display();
    }
}

Deprecatedtest display()

From java.lang.annotation

1. @Documented 

• Marks annotations to be included in generated Javadoc.
• Improves API documentation clarity.

2. @Target 

• Specifies where the annotation can be applied (class, method, field, etc.).
• Prevents misuse of annotations in wrong places.

3. @Inherited 

• Allows a subclass to inherit an annotation from its parent class.
• Useful in frameworks where annotations define behavior across hierarchies.

User-defined (Custom) Annotation

User-defined annotations can be used to annotate program elements, i.e. variables, constructors, methods, etc. These annotations can be applied just before the declaration of an element (constructor, method, classes, etc). 

Syntax

[Access Specifier] @interface<AnnotationName>

{
DataType <Method Name>() [default value];
}

Do keep these certain points as rules for custom annotations before implementing user-defined annotations. 

• AnnotationName is an interface.
• The parameter should not be associated with method declarations and throws clause should not be used with method declaration.
• Parameters will not have a null value but can have a default value.
• default value is optional.
• The return type of method should be either primitive, enum, string, class name or array of primitive, enum, string or class name type.

Example: Java Program to Demonstrate User-defined Annotations

package source;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

// User-defined annotation
@Documented
@Retention(RetentionPolicy.RUNTIME)
@ interface TestAnnotation
{
    String Developer() default "Rahul"; 
    String Expirydate();
} // will be retained at runtime

// Driver class that uses @TestAnnotation
public class Test
{
    @TestAnnotation(Developer="Rahul", Expirydate="01-10-2020")
    void fun1()
    {
        System.out.println("Test method 1");
    }

    @TestAnnotation(Developer="Anil", Expirydate="01-10-2021")
    void fun2()
    {
        System.out.println("Test method 2");
    }
    
    public static void main(String args[])
    {
        System.out.println("Hello");
    }
}

Output: 

Hello

Suggested Quiz

Edit Quiz

3 Questions

What is the main purpose of annotations in Java?

• A

  To improve program execution speed

• B

  To change the logic of compiled code

• C

  To provide metadata about program elements

• D

  To replace comments entirely

Explanation:

Annotations provide metadata that can be used by the compiler or runtime without changing program logic.

Which type of annotation does NOT contain any elements or values?

• A

  Single value annotation

• B

  Full annotation

• C

  Marker annotation

• D

  Repeating annotation

Explanation:

Marker annotations only indicate presence and do not contain any elements.

Which annotation category was introduced in Java 8 to annotate types like variables and return types?

• A

  Marker Annotations

• B

  Repeating Annotations

• C

  Type Annotations

• D

  Full Annotations

  
  

Explanation:

Type annotations (introduced in Java 8) allow annotations on types using ElementType.TYPE_USE.

Quiz Completed Successfully

Your Score :   2/3

Accuracy :  0%

Login to View Explanation

1/3 1/3 < Previous Next >