Java – Anotaciones @Target – Part 1

Anotacionesen java se utilizan para asociar metadatos a elementos de programa como clases, métodos, variables de instancia, etc. Hay principalmente tres tipos de anotaciones en java: Anotación de marcador (sin ningún método), Anotación de valor único (con un método único) y Anotación de valores múltiples (con más de un método). La anotación @Target es una meta-anotación, es decir, solo se puede usar para anotar otras anotaciones. Toma la enumeración de ElementType como su único argumento. La enumeración ElementType es una constante que especifica el tipo de declaración del elemento del programa (clase, interfaz, constructor, etc.) a la que se puede aplicar la anotación. Si aplicamos la anotación @Target con algún tipo de elemento como anotación a un nombre de anotación personalizado CustomAnnotation,  

La siguiente tabla muestra los tipos de elementos, y la declaración de elementos que se puede anotar se menciona a continuación de la siguiente manera:

Para usar la anotación @Target, siga la siguiente sintaxis de la siguiente manera: 

Sintaxis:

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

En el ejemplo de código mencionado anteriormente, hemos creado una anotación personalizada anotada con la anotación @Target. Dado que hemos utilizado ElementType como TIPO, la anotación personalizada solo puede anotar una clase, enumeración o interfaz. También podemos crear una anotación personalizada que se puede aplicar a varios elementos proporcionando una lista delimitada por llaves de tipos de elementos como argumento para la anotación @Target como se muestra a continuación.

Sintaxis:

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

La anotación personalizada creada anteriormente se puede usar para anotar un método o un paquete. El código mencionado a continuación muestra cómo podemos usar la anotación @Target. Hemos creado dos anotaciones personalizadas: una que se puede aplicar a un solo tipo de elemento y otra que se puede aplicar a varios tipos de elementos. Luego aplicamos estas anotaciones a nuestra clase y método, y finalmente, imprimimos estas anotaciones buscándolas.

Implementación:

Ejemplo 

// 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]);
    }
}

@ClassAnnotation(value="Can annotate a class")
@MultipleElementTypeAnnotation(value="Can annotate a class, method, annotation, or constructor")