Annotazioni in Java: tipi, usi ed esempi

Un'annotazione in un linguaggio di programmazione come Java si riferisce ai metadati sintattici che possono essere integrati con il codice sorgente di Java. È possibile annotare vari fattori come pacchetti Java, variabili, classi, parametri e metodi. Gli sviluppatori possono leggere facilmente le annotazioni Java direttamente dai file di origine, proprio come i tag Javadoc.

Le annotazioni Java possono anche essere incluse e lette dai file di classe Java di output del compilatore Java. Ciò consente alla macchina virtuale Java di mantenere le annotazioni e leggerle attraverso una riflessione in fase di esecuzione. In Java, è possibile creare meta-annotazioni da quelle esistenti.

Queste sono alcune nozioni di base sulle annotazioni in Java:

1. Le annotazioni iniziano sempre con una "@". Ad esempio: '@override', '@target', '@SuppressWarnings', ecc.
2. Le annotazioni non influiscono sul comportamento di un programma compilato.
3. Le annotazioni aiutano ad associare i metadati ai componenti del programma come metodi, classi, variabili, ecc.
4. Le annotazioni non sono solo commenti poiché possono influenzare il modo in cui un programma viene elaborato dal compilatore. Offrono informazioni aggiuntive sul compilatore sul programma ma non fanno parte del programma stesso. Pertanto, queste annotazioni non influiscono sull'esecuzione del programma compilato.

Tipi di annotazioni in Java

1. Annotazioni a valore singolo

Le annotazioni a valore singolo consentono un solo modulo abbreviato poiché contengono un solo membro. Al membro deve essere assegnato un valore dopo l'applicazione dell'annotazione. Tuttavia, non è necessario specificare il nome dell'annotazione. Il membro deve avere un valore se deve essere utilizzata la abbreviazione. Per esempio:

@TestAnnotation("test");

2. Annotazioni complete

Le annotazioni complete sono costituite da vari dati come membri dati, valori, coppie e nomi.

Per esempio:

@TestAnnotation(owner=”Rahul”, valore=”Class Geeks”)

Impara i corsi di sviluppo software online dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

3. Annotazioni ripetute

Quando un'annotazione può essere applicata a oggetti singoli più di una volta, viene etichettata come un'annotazione ripetuta. Le annotazioni ripetute sono specificate con il tag @Repeatable come definito nel pacchetto java.lang.annotation. Il suo campo valore indica il tipo di contenitore dell'annotazione ripetuta.

Il contenitore è definito come un'annotazione con un campo valore che contiene una matrice di annotazioni ripetute. Per costruire un'annotazione ripetuta, creare prima l'annotazione contenitore, quindi specificare il tipo di annotazione come input per l'annotazione @Repeatable.

Per esempio:

// Programma Java per dimostrare un'annotazione ripetibile

// Importazione delle classi richieste

import java.lang.annotation.Annotation;

import java.lang.annotation.Ripetibile;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.reflect.Method;

// Rendi ripetibile l'annotazione di Words

@Retention(RetentionPolicy.RUNTIME)

@Repeated(MyRepeatedAnnos.class)

@Interface Parole

{

Parola stringa() predefinita "Ciao";

int valore() predefinito 0;

}

// Crea annotazione contenitore

@Retention(RetentionPolicy.RUNTIME)

@interfaccia MyRepeatedAnnos

{

Parole[] valore();

}

classe pubblica Principale {

// Ripeti parole su newMethod

@Parole(parola = "Primo", valore = 1)

@Parole(parola = "Secondo", valore = 2)

public static void newMethod()

{

Main obj = new Main();

Tentativo {

Classe<?> c = obj.getClass();

// Ottieni l'annotazione per newMethod

Metodo m = c.getMethod(“nuovoMetodo”);

// Visualizza l'annotazione ripetuta

Annotazione anno

= m.getAnnotation(MyRepeatedAnnos.class);

System.out.println(anno);

}

cattura (NoSuchMethodException e) {

System.out.println(e);

}

}

public static void main(String[] args) { newMethod(); }

}

L'output finale sarebbe: @MyRepeatedAnnos(value={@Words(value=1, word=”First”), @Words(value=2, word=”Second”)})

Esplora i nostri corsi di ingegneria del software popolari

3. Annotazioni dei marker

Le annotazioni dei marker sono pensate solo a scopo di dichiarazione. Né questa annotazione contiene membri né esistono dati al suo interno. Il suo unico scopo è mantenere una presenza come annotazione. Ad esempio: @Override.

4. Digitare le annotazioni

Queste annotazioni possono essere utilizzate ovunque venga utilizzato un tipo. Ad esempio, possiamo annotare il tipo restituito di un metodo. Le annotazioni di tipo sono contrassegnate con l'annotazione @Target.

Il codice che può illustrare le annotazioni di tipo è:

// Importazione delle classi richieste

import java.lang.annotation.ElementType;

import java.lang.annotation.Target;

// Utilizzo dell'annotazione di destinazione per annotare un tipo

@Target(TipoElemento.TYPE_USE)

// Dichiarazione di un'annotazione di tipo semplice

@Interface TypeAnnoDemo{}

// Classe principale

classe pubblica GFG {

// Metodo del driver principale

public static void main(String[] args) {

// Annotazione del tipo di una stringa

@TypeAnnoDemo String string = "Questo codice è annotato con un'annotazione di tipo";

System.out.println(stringa);

abc();

}

// Annotazione del tipo restituito di una funzione

statico @TypeAnnoDemo int abc() {

System.out.println(“Il tipo restituito di questa funzione è annotato”);

restituire 0;

}

Esempi di annotazioni predefinite

Ci sono molte varietà di annotazioni predefinite che abbiamo menzionato in precedenza. Diamo un'occhiata:

1. @Sostituisci

Questa annotazione del marcatore può essere utilizzata solo sui metodi. Qualsiasi metodo con l'annotazione @override deve sostituire un altro metodo di una superclasse. In caso contrario, viene attivato un errore in fase di compilazione. Ciò accade poiché deve garantire che la superclasse sia effettivamente sovrascritta e non solo sovraccaricata.

Il codice che può illustrare l'annotazione di sostituzione è:

// Classe 1

Classe Base

{

display vuoto pubblico()

{

System.out.println("Visualizzazione di base()");

}

public static void main(String args[])

{

Base t1 = nuovo Derivato();

t1.Display();

}

}

// Classe 2

// Estendere al di sopra della classe

la classe Derivato estende Base

{

@Oltrepassare

display vuoto pubblico()

{

System.out.println("Display derivato()");

}

}

2. @Target

È pensato solo per essere utilizzato come annotazione per un'altra annotazione. @Target accetta un parametro, che deve essere una costante ElementType. Il parametro decide a quali dichiarazioni può essere applicato. L'annotazione @Target può avere più valori anziché solo un valore singolare. Tuttavia, se devono essere dichiarati più valori, devono essere sotto forma di parentesi graffe come: @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE}).

L'annotazione @Retention può essere utilizzata qui per determinare lo stato di conservazione dell'annotazione. Tre fattori influenzano un'annotazione @Retention:

• Sorgente: il compilatore ignora le annotazioni poiché di solito vengono mantenute a livello di origine.
• Runtime: viene mantenuto in runtime.
• Classe: le annotazioni rimangono in fase di compilazione e vengono ignorate dal programma Java.

3. @Ereditato

Questa annotazione può essere utilizzata solo a scopo di dichiarazione e, quindi, influisce solo su determinate dichiarazioni di classe. Un'annotazione può sostituire l'altra ed ereditarne le proprietà. Pertanto, la superclasse può essere verificata se nella sottoclasse sono assenti annotazioni specifiche. Tuttavia, se l'annotazione è presente, ottiene l'annotazione @Inherited.

Per esempio:

// Classe 1

classe DeprecatedTest

{

@Deprecato

display vuoto pubblico()

{

System.out.println("Deprecatedtest display()");

}

}

// Classe 2

classe pubblica SuppressWarningTest

{

// Se commentiamo sotto l'annotazione, il programma genera

// avvertimento

@SuppressWarnings({"checked", "deprecation")})

public static void main(String args[])

{

DeprecatedTest d1 = new DeprecatedTest();

d1.Display();

}

}

Conclusione

Qui abbiamo imparato le annotazioni in Java. Abbiamo anche appreso i tipi di annotazioni in Java e i loro usi che possono aiutare gli sviluppatori Java a creare facilmente programmi robusti e scalabili.

Se desideri saperne di più sui concetti Java, la certificazione PG collegata al lavoro di upGrad in ingegneria del software è la soluzione migliore per acquisire una comprensione completa di linguaggi di programmazione come Java, HTML, JS, nonché altri strumenti e librerie di sviluppo software.

Il programma è progettato per studenti dell'ultimo anno o laureati disoccupati che desiderano assicurarsi posizioni di livello base nel campo. Il corso di 5 mesi copre la specializzazione in MERN/Cloud-Native e aiuta gli studenti a costruire un portfolio di prima classe esponendoli a 5 progetti pratici.

Quindi, non aspettare. Vai su upGrad e prenota il tuo posto oggi!