Comprensione delle annotazioni Java – Tutorial Java @annotations

Pubblicato: 2019-10-22
Annotazioni a livello di pacchetto

Come e dove vengono utilizzate le annotazioni in Java?

Un'annotazione, nel linguaggio di programmazione per computer Java, è una forma speciale di metadati sintattici che possono essere aggiunti al codice sorgente Java.

Classi, metodi, variabili, parametri e pacchetti possono essere annotati. A differenza dei tag Javadoc, le annotazioni Java possono essere riflessive in quanto possono essere incorporate nei file di classe generati dal compilatore e possono essere conservate dalla Java VM per essere recuperate in fase di esecuzione.

È possibile creare meta-annotazioni da quelle esistenti in Java, il che rende questo concetto più sofisticato.

Java definisce una serie di annotazioni integrate nel linguaggio.

Comprensione delle annotazioni Java - Suggerimenti per Crunchify
Comprensione delle annotazioni Java – Suggerimenti per Crunchify

Annotazioni applicate al codice java:

  • @Override – Verifica che la funzione sia un override. Genera un avviso di compilazione se la funzione non viene trovata in una delle classi padre.
  • @Deprecated – Contrassegna la funzione come obsoleta. Genera un avviso di compilazione se viene utilizzata la funzione.
  • @SuppressWarnings – Indica al compilatore di eliminare gli avvisi di compilazione specificati nei parametri di annotazione.

Annotazioni applicate ad altre annotazioni:

  • @Retention : specifica come viene archiviata l'annotazione contrassegnata: solo nel codice, compilata nella classe o disponibile in fase di esecuzione tramite riflessione.
  • @Documented : contrassegna un'altra annotazione per l'inclusione nella documentazione.
  • @Target – Contrassegna un'altra annotazione per limitare il tipo di elementi Java a cui può essere applicata l'annotazione.
  • @Inherited – Contrassegna un'altra annotazione da ereditare nelle sottoclassi della classe annotata (per impostazione predefinita, le annotazioni non vengono ereditate nelle sottoclassi).

Diamo un'occhiata a questi tramite esempi di esempio:

1) @Sostituisci annotazione:

La sua presenza indica al compilatore che il metodo annotato deve sovrascrivere un metodo di superclasse esistente.

Il caso d'uso più comune per @Override è con i metodi Object :

1
2
3
4
@ Override
public int hashValue ( ) {
     System . out . Println ( "This method is using @Override Annotation" ) ;
}

Il motivo principale per cui è stato creato @Override era per gestire semplici errori tipografici .

Ad esempio, un metodo dichiarato erroneamente come

1
public int hashvalue ( ) { . . . }

in effetti non è un override: il nome del metodo ha tutte lettere minuscole, quindi non corrisponde esattamente al nome del metodo hashValue() . Comunque si compilerà perfettamente. Un errore del genere è facile da fare e difficile da cogliere, il che è una combinazione pericolosa. L'uso dell'annotazione @Override impedisce di commettere tali errori.

Dovresti avere l'abitudine di usare @Override ogni volta che esegui l'override di un metodo di superclasse.

Comprensione delle annotazioni Java

2) @Annotazione deprecata:

Questa annotazione indica che l'elemento contrassegnato è obsoleto e non deve più essere utilizzato. Il compilatore genera un avviso ogni volta che un programma utilizza un metodo, una classe o un campo con l'annotazione @Deprecated .

Quando un elemento è deprecato, dovrebbe anche essere documentato utilizzando il tag Javadoc @deprecated , come mostrato nell'esempio seguente.

1
2
3
4
< strong > @ Deprecated < / strong >
static void deprecatedMethod ( ) {
     System . out . Println ( "This method is Deprecated.." ) ;
}

3) Annotazione @SuppressWarnings:

Dillo al compilatore, per favore non urlare. So cosa sto facendo .

1
2
3
4
@ SuppressWarnings ( "serial" )
public class OldCode implements Serializable {
System . out . Println ( "This is Old Code.." ) ;
}

4) @Annotazione di conservazione:

L'annotazione di conservazione indica dove e per quanto tempo devono essere conservate le annotazioni con questo tipo.

Ci sono tre valori:

  • RetentionPolicy.SOURCE : le annotazioni con questo tipo verranno conservate solo a livello di origine e verranno ignorate dal compilatore.
  • RetentionPolicy.CLASS —Le annotazioni con questo tipo verranno conservate dal compilatore in fase di compilazione, ma verranno ignorate dalla macchina virtuale.
  • RetentionPolicy.RUNTIME : le annotazioni con questo tipo verranno conservate dalla macchina virtuale in modo che possano essere lette solo in fase di esecuzione.
1
2
3
4
@ Retention ( RetentionPolicy . RUNTIME )
public @ interface Crunchify_Retention {
   String returnSomething ( ) ;
}

5) @Annotazione documentata:

1
2
3
4
@ Documented
public @ interface Crunchify_Documented {
   String writeDocument ( ) ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DocumentedAnnotations {
   public static void main ( String arg [ ] ) {
       new DocumentedAnnotations ( ) . performRetention ( ) ;
       new DocumentedAnnotations ( ) . performDocumented ( ) ;
   }
   @ Crunchify_Retention ( returnSomething = "Hello retention test" )
   public void performRetention ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Retention'" ) ;
   }
   @ Crunchify_Documented ( writeDocument = "Hello document" )
   public void performDocumented ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Documented'" ) ;
   }
}

Ora prova a eseguire il comando Java Doc e vedi l'output.

6) Annotazione @Target:

Destinazione indica quali elementi del programma possono essere annotati utilizzando le istanze del tipo di annotazione annotata. Il valore di Target è uno dei membri java.lang.annotation.ElementType :

  1. ANNOTATION_TYPE. Il tipo di annotazione annotata può essere utilizzato per annotare la dichiarazione del tipo di annotazione.
  2. COSTRUTTORE. Il tipo di annotazione annotata può essere utilizzato per annotare la dichiarazione del costruttore.
  3. CAMPO. Il tipo di annotazione annotata può essere utilizzato per annotare la dichiarazione del campo.
  4. LOCALE_VARIABILE. Il tipo di annotazione annotata può essere utilizzato per annotare la dichiarazione di variabile locale.
  5. METODO. Il tipo di annotazione annotata può essere utilizzato per annotare la dichiarazione del metodo.
  6. PACCHETTO. Il tipo di annotazione annotata può essere utilizzato per annotare le dichiarazioni dei pacchetti.
  7. PARAMETRO. Il tipo di annotazione annotata può essere utilizzato per annotare le dichiarazioni dei parametri.
  8. GENERE. Il tipo di annotazione annotata può essere utilizzato per annotare le dichiarazioni di tipo.
1
2
3
4
@ Target ( value = METHOD )
You can have multiple values in the Target annotation .
 
@ Target ( value = { TYPE , FIELD , METHOD , PARAMETER , CONSTRUCTOR , LOCAL_VARIABLE } )

7) @Annotazione ereditata:

Esattamente come suona il nome, un tipo di annotazione @Inherited viene ereditato dalle sottoclassi di un tipo annotato.

1
2
3
4
5
6
7
8
9
10
@ Inherited
@ interface ForEveryone { }
 
@ interface JustForMe { }
 
@ ForEveryone
@ JustForMe
class Superclass { }
 
class Subclass extends Superclass { }

In questo esempio, Superclass è stata annotata in modo esplicito sia con @ForEveryone che con @JustForMe . Subclass non è stata contrassegnata esplicitamente con nessuna delle due; tuttavia, eredita @ForEveryone perché quest'ultimo è annotato con @Inherited .

@JustForMe non è annotato, quindi non è ereditato da Subclass .

Ecco le annotazioni a livello di classe

Annotazioni a livello di classe