Esistono tre tipi di annotazioni.

1. Annotazione del marcatore
2. Annotazione a valore singolo
3. Annotazione multivalore

L'annotazione del marcatore è un'annotazione senza un metodo. Per esempio:

@interface MyAnnotation{}

2) Annotazione a valore singolo

L'annotazione a valore singolo è un tipo di annotazione che contiene un solo metodo. Per esempio:

@interface MyAnnotation{
int value();
}

@interface MyAnnotation{
int value() default 0;
}

Diamo un'occhiata al codice per l'utilizzo dell'annotazione a valore singolo.

@MyAnnotation(value=10)

3) Annotazione multivalore

Un'annotazione con più metodi è nota come annotazione multivalore. Come esempio:

@interface MyAnnotaion{
int value1();
String value1();
String value2();
String value3();
}
}

@interface MyAnnotation{
int value1() default 1;
String value2() default "";
String value3() default "xyz";
}

Diamo un'occhiata al codice per l'utilizzo dell'annotazione multivalore.

@MyAnnotation(value1 = 10, value2 = "Arun Kumar", value3 = "Ghaziabad")

• @Obbiettivo
• @Ritenzione
• @Ereditato
• @Documentato

Il tag @Target viene utilizzato per specificare a quale tipo viene applicata l'annotazione.

L'annotazione in java.lang.

L'ElementType enum dichiara un numero di costanti che specificano il tipo di elemento a cui verrà applicata l'annotazione, ad esempio TYPE, METHOD, FIELD e così via. Diamo un'occhiata alle costanti enum ElementType:

Esempio per specificare le annotazioni per una classe

@Target(ElementType.TYPE)
@interface MyAnnotation{
int value1();
String value2();
}

@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
@interface MyAnnotation{
int value1();
String value2();
}

L'annotazione @Retention specifica il livello di annotazione che sarà disponibile.

Esempio per specificare RetentionPolicy

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface MyAnnotation{
int value1();
String value2();
}

Diamo un'occhiata a un esempio di base di creazione, applicazione e accesso all'annotazione.

//Creating annotation
import java.lang.annotation.*;
import java.lang.reflect.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnnotation{
int value(();
}
//Applying annotation
class Hello{
@MyAnnotation(value = 10)
public void sayHello(){System.out.println("hello annotation");}
}
//Accessing annotation
class TestCustomAnnotation1{
public static void main(String args[])throws Exception{
Hello h = new Hello();
Method m = h.getClass().getMethod("sayHello");
MyAnnotation manno = m.getAnnotation(MyAnnotation.class);
System.out.pirntln("value is:" + manno.value());
}}

value is: 10

In pratica, un programmatore java deve usare solo l'annotazione. Non è tenuto a creare o accedere alle annotazioni. Il fornitore dell'implementazione è responsabile della creazione e dell'accesso alle annotazioni. Il compilatore java o JVM esegue alcune operazioni aggiuntive per conto dell'annotazione.

@Ereditato

Le annotazioni non vengono ereditate dalle sottoclassi per impostazione predefinita. L'annotazione @Inherited indica che l'annotazione verrà ereditata dalle sottoclassi.

@Inherited
@interface ForEveryone{}//Now it will be available to subclass also
@interface ForEveryone{}
class Superclass{}
class Subclass extends Superclass{}

Il @Documented Contrassegna l'annotazione per l'inclusione nella documentazione.