Giava Annotazione è un tag che rappresenta il metadati cioè allegato a classe, interfaccia, metodi o campi per indicare alcune informazioni aggiuntive che possono essere utilizzate dal compilatore Java e dalla JVM.

Le annotazioni in Java vengono utilizzate per fornire informazioni aggiuntive, quindi si tratta di un'opzione alternativa per le interfacce dei marcatori XML e Java.

Per prima cosa impareremo alcune annotazioni integrate, quindi passeremo alla creazione e all'utilizzo di annotazioni personalizzate.

Annotazioni Java integrate

Esistono diverse annotazioni integrate in Java. Alcune annotazioni vengono applicate al codice Java e altre ad altre annotazioni.

Annotazioni Java integrate utilizzate nel codice Java

• @Oltrepassare
• @SuppressWarnings
• @Deprecato

Annotazioni Java integrate utilizzate in altre annotazioni

• @Bersaglio
• @Ritenzione
• @Ereditato
• @Documentato

Comprendere le annotazioni integrate

Comprendiamo prima le annotazioni integrate.

@Oltrepassare

L'annotazione @Override assicura che il metodo della sottoclasse sovrascriva il metodo della classe genitore. Se non è così, si verifica un errore in fase di compilazione.

A volte, commettiamo errori stupidi come errori di ortografia, ecc. Quindi, è meglio contrassegnare l'annotazione @Override che fornisce la garanzia che il metodo venga sovrascritto.

confrontare in stringa

 class Animal{ void eatSomething(){System.out.println('eating something');} } class Dog extends Animal{ @Override void eatsomething(){System.out.println('eating foods');}//should be eatSomething } class TestAnnotation1{ public static void main(String args[]){ Animal a=new Dog(); a.eatSomething(); }} 

 Output:Comple Time Error 

@SuppressWarnings

Annotazione @SuppressWarnings: viene utilizzata per sopprimere gli avvisi emessi dal compilatore.

 import java.util.*; class TestAnnotation2{ @SuppressWarnings('unchecked') public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('sonoo'); list.add('vimal'); list.add('ratan'); for(Object obj:list) System.out.println(obj); }} 

 Now no warning at compile time. 

Se rimuovi l'annotazione @SuppressWarnings('unchecked'), verrà visualizzato un avviso in fase di compilazione perché stiamo utilizzando una raccolta non generica.

@Deprecato

L'annotazione @Deprecated indica che questo metodo è deprecato, quindi il compilatore stampa un avviso. Informa l'utente che potrebbe essere rimosso nelle versioni future. Quindi, è meglio non usare tali metodi.

quanto fa 10 su 100?

 class A{ void m(){System.out.println('hello m');} @Deprecated void n(){System.out.println('hello n');} } class TestAnnotation3{ public static void main(String args[]){ A a=new A(); a.n(); }} 

Al momento della compilazione:

 Note: Test.java uses or overrides a deprecated API. <br> Note: Recompile with -Xlint:deprecation for details. 

In fase di esecuzione:

 hello n 

Annotazioni personalizzate Java

Annotazioni personalizzate Java o Java Le annotazioni definite dall'utente sono facili da creare e utilizzare. IL @interfaccia L'elemento viene utilizzato per dichiarare un'annotazione. Per esempio:

 @interface MyAnnotation{} 

Qui, MyAnnotation è il nome dell'annotazione personalizzata.

Punti da ricordare per la firma delle annotazioni personalizzate Java

Ci sono alcuni punti che dovrebbero essere ricordati dal programmatore.

1. Il metodo non dovrebbe avere clausole Throws
2. Il metodo deve restituire uno dei seguenti: tipi di dati primitivi, stringa, classe, enumerazione o array di questi tipi di dati.
3. Il metodo non deve avere alcun parametro.
4. Dovremmo allegare @ subito prima della parola chiave dell'interfaccia per definire l'annotazione.
5. Può assegnare un valore predefinito al metodo.

Tipi di annotazione

Esistono tre tipi di annotazioni.

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

1) Annotazione del marcatore

Un'annotazione che non ha metodo è chiamata annotazione marcatore. Per esempio:

 @interface MyAnnotation{} 

@Override e @Deprecated sono annotazioni marcatore.

2) Annotazione a valore singolo

Un'annotazione che ha un metodo è chiamata annotazione a valore singolo. Per esempio:

 @interface MyAnnotation{ int value(); } 

Possiamo fornire anche il valore predefinito. Per esempio:

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

Come applicare l'annotazione a valore singolo

Vediamo il codice per applicare l'annotazione a valore singolo.

cos'è l'oracolo

 @MyAnnotation(value=10) 

Il valore può essere qualsiasi cosa.

3) Annotazione multivalore

Un'annotazione che ha più di un metodo è chiamata annotazione multivalore. Per esempio:

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

Possiamo fornire anche il valore predefinito. Per esempio:

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

Come applicare l'annotazione multivalore

Vediamo il codice per applicare l'annotazione multivalore.

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

Annotazioni integrate utilizzate nelle annotazioni personalizzate in Java

• @Bersaglio
• @Ritenzione
• @Ereditato
• @Documentato

@Bersaglio

@Bersaglio il tag viene utilizzato per specificare in quale tipo viene utilizzata l'annotazione.

L'annotazione java.lang. TipoElemento enum dichiara molte costanti per specificare il tipo di elemento a cui applicare l'annotazione come TYPE, METHOD, FIELD ecc. Vediamo le costanti di ElementType enum:

cifra romana da 1 a 100

Esempio per specificare l'annotazione per una classe

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

Esempio per specificare l'annotazione per una classe, metodi o campi

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

@Ritenzione

@Ritenzione l'annotazione viene utilizzata per specificare a quale livello l'annotazione sarà disponibile.

Esempio per specificare RetentionPolicy

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

Esempio di annotazione personalizzata: creazione, applicazione e accesso all'annotazione

Vediamo il semplice esempio di creazione, applicazione e accesso all'annotazione.

File: Prova.java

 //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.println('value is: '+manno.value()); }} 

 Output:value is: 10 

Come vengono utilizzate le annotazioni integrate nello scenario reale?

Nello scenario reale, il programmatore Java deve solo applicare l'annotazione. Non è necessario che crei e acceda all'annotazione. La creazione e l'accesso all'annotazione vengono eseguiti dal provider dell'implementazione. Per conto dell'annotazione, il compilatore Java o JVM esegue alcune operazioni aggiuntive.

@Ereditato

Per impostazione predefinita, le annotazioni non vengono ereditate dalle sottoclassi. L'annotazione @Inherited contrassegna l'annotazione da ereditare nelle sottoclassi.

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

@Documentato

@Documented Contrassegna l'annotazione da includere nella documentazione.