Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Java – @Targeted Annotations

  • Last Updated : 06 Aug, 2021

Annotations in java are used to associate metadata to program elements like classes, methods, instance variables, etc. There are mainly three types of annotations in java: Marker Annotation (without any methods), Single-Valued Annotation (with a single method), and Multi-Valued Annotation (with more than one method). @Target annotation is a meta-annotation, i.e., it can only be used to annotate other annotations. It takes ElementType enumeration as its only argument. ElementType enumeration is a constant which specifies the type of the program element declaration (class, interface, constructor, etc.) to which the annotation can be applied. If we apply the @Target annotation with some ElementType as an annotation to a custom annotation name CustomAnnotation, then @CustomAnnotation can only be used to annotate those specific elements types otherwise we will get an error.  

The table below shows the element types, and the element declaration that can be annotated are mentioned below as follows:

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Element Type Element to be Annotated 
Type Class, interface or enumeration
Field Field
Method Method 
ConstructorConstructor
Local_Variable Local variable 
Annotation_Type Annotation Type 
Package PACKAGE
Type_ParameterType Parameter 
Parameter Formal Parameter 

In order to use @Target annotation follow the below syntax as follows: 

Syntax:



@Target(ElementType.TYPE)
@interface CustomAnnotation {}

In the code sample mentioned above, we have created a custom annotation annotated using @Target annotation. Since we have used ElementType as TYPE, therefore, the custom annotation can only annotate a class, enumeration, or interface. We can also create a custom annotation that can be applied to multiple elements by giving a braces-delimited list of element types as an argument to @Target annotation as shown below.

Syntax:

@Target({ElementType.METHOD, ElementType.PACKAGE})
@interface CustomAnnotation {}

The custom annotation created above can be used to annotate a method or a package. The code mentioned below shows how we can use @Target annotation. We have created two custom annotations: one which can be applied to a single element type and one which can be applied to multiple element types. Then we apply these annotations to our class and method, and finally, we print these annotations by fetching them.

Implementation:

Example 

Java




// Java program to Illustrate Targeted Annotations
 
// Importing required classes from java.lang package 
import java.lang.annotation.*;
 
// Creating a custom annotation with target
// as TYPE which means it can annotate a class,
// enumeration, or interface
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
 
// Class Annotation
@interface ClassAnnotation
{
    String value() default "Can annotate a class";
}
 
// Creating custom annotation with
// target as multiple Element types as parameters
// which means it can annotate various Elements
@Target({ ElementType.METHOD, ElementType.TYPE,
          ElementType.ANNOTATION_TYPE,
          ElementType.CONSTRUCTOR })
@Retention(RetentionPolicy.RUNTIME)
@interface MultipleElementTypeAnnotation
{
 
    String value() default "Can annotate a class, method, "
        + "annotation, or constructor";
}
 
// Class to demonstrate the use of custom
// created annotations
@ClassAnnotation
 
// Main class
// TargetAnnotationDemo
public class GFG {
 
    @MultipleElementTypeAnnotation public void myMethod() {}
 
    // Main drive method
    public static void main(String[] args) throws Exception
    {
        GFG obj = new GFG();
 
        // Accessing the annotations used to annotate the
        // class and storing them in an array of Annotation
        // type since only one annotation is used to
        // annotate our class therefore we print a[0]
        Annotation a[] = obj.getClass().getAnnotations();
 
        System.out.println(a[0]);
 
        // Accessing the annotations used to annotate the
        // method and storing them in an array of Annotation
        // type
        Class<?> className = Class.forName("GFG");
        Annotation b[] = className.getMethod("myMethod")
                             .getAnnotations();
 
        System.out.println(b[0]);
    }
}
Output
@ClassAnnotation(value="Can annotate a class")
@MultipleElementTypeAnnotation(value="Can annotate a class, method, annotation, or constructor")

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :