教程基础Java

Java Controllo dei Flussi

Java Array

Java Orientato agli Oggetti (I)

Java Orientato agli Oggetti (II)

Java Orientato agli Oggetti (III)

Gestione delle eccezioni Java

Java List

Java Queue (Coda)

Java Map Collection

Java Set Collection

Java Input/Output (I/O)

Java Reader/Writer

Altri argomenti Java

Sovraccarico di metodi Java try-with-resources Java

Annotationi Java

In questo tutorial, impareremo cosa sono le annotazioni, diversi tipi di annotazioni Java e come utilizzarle con esempi.

Le annotazioni Java sono i metadati del nostro codice sorgente (informazioni sugli dati).

Forniscono informazioni aggiuntive al compilatore sul programma, ma non sono parte del programma stesso. Queste annotazioni non influenzano l'esecuzione del programma compilato.

Le annotazioni iniziano con @. La loro sintassi è:

@AnnotationName

Prendiamo ad esempio l'annotazione @Override.

@Override annota il metodo che riscrive un metodo con lo stesso nome, tipo di ritorno e elenco dei parametri del metodo della superclasse.

Quando si riscrive un metodo, non è necessario utilizzare @Override. Tuttavia, se lo si utilizza, il compilatore fornirà un errore durante la riscrittura del metodo, se si verifica un errore (ad esempio, un tipo di parametro errato).

Esempio 1: esempio di annotazione @Override

class Animal {
　　public void displayInfo() {
　　　　System.out.println("Io sono un animale.");
　　}
}
class Dog extends Animal {
　　@Override
　　public void displayInfo() {
　　　　System.out.println("Io sono un cane.");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog d1 = new Dog();
　　　　d1.displayInfo();
　　}
}

risultato di output

Io sono un cane.

In questo esempio, il metodo displayInfo() esiste sia nella classe padre Animal che nella classe figlia Dog. Quando si chiama questo metodo, verrà chiamato il metodo della classe figlia, non quello della classe superiore.

Formato dell'annotazione

Le annotazioni possono anche includere elementi (membri/proprietà/parametri).

1. Annotazioni di etichetta

Le annotazioni di etichetta non contengono membri/elementi. Servono solo a etichettare le dichiarazioni.

La sua sintassi è:

@AnnotationName()

Poiché queste annotazioni non contengono elementi, non è necessario utilizzare parentesi. Ad esempio:

@Override

2. Annotazioni a singolo elemento

Le annotazioni a singolo elemento contengono solo un elemento.

La sua sintassi è:

@AnnotationName(elementName = "elementValue")

Se c'è un solo elemento, è consuetudine chiamarlo value.

@AnnotationName(value = "elementValue")

In questo caso, è anche possibile rimuovere il nome dell'elemento. Il nome dell'elemento value è predefinito.

@AnnotationName("elementValue")

3. Annotazioni a più elementi

Queste annotazioni contengono più elementi separati da virgola.

La sua sintassi è:

@AnnotationName(element1 = "value1", element2 = "value2")

Posizione dell'annotazione

Qualsiasi dichiarazione può essere etichettata con un'annotazione ponendola sopra la dichiarazione stessa. A partire da Java 8, i commenti possono anche essere posizionati prima del tipo.

1. Sopra la dichiarazione

Come descritto sopra, i commenti Java possono essere posizionati sopra le dichiarazioni di classi, metodi, interfacce, campi e altri elementi del programma.

Esempio 2: esempio di annotazione @SuppressWarnings

import java.util.*;
class Main {
　　@SuppressWarnings("unchecked")
　　static void wordsList() {
　　　　ArrayList wordList = new ArrayList<>();
　　　　// Questo causerà un avviso non controllato
　　　　wordList.add("w3codebox");　
　　　　System.out.println("Word list => " + wordList);
　　}
　　public static void main(String args[]) {
　　　　wordsList();
　　}
}

risultato di output

Word list => [w3codebox]

Se il programma sopra indicato viene compilato senza l'annotazione @SuppressWarnings("unchecked"), il compilatore compilerà comunque il programma, ma fornirà il seguente avviso:

Main.java utilizza operazioni non controllate o non sicure.
Word list => [w3codebox]

riceviamo un avviso

Main.java utilizza operazioni non controllate o non sicure

perché della seguente istruzione.

ArrayList wordList = new ArrayList<>();

Questo è perché non abbiamo ancora definito il tipo generico dell'array list. Possiamo risolvere questo avviso specificando il tipo tra parentesi angolari <>.

ArrayList<String> wordList = new ArrayList<>();

2. Commenti di tipo

Prima di Java 8, i commenti potevano essere applicati solo alle dichiarazioni. Ora, possono essere utilizzati anche i commenti di tipo. Questo significa che possiamo inserire annotazioni in qualsiasi luogo si utilizzi il tipo.

chiamata al costruttore

new @Readonly ArrayList<>()

definizione di tipo

@NonNull String str;

Questa dichiarazione specifica una variabile non nulla di tipo String chiamata str per evitare NullPointerException.

@NonNull List<String> newList;

Questa dichiarazione specifica una lista non nulla di tipo String.

List<@NonNull String> newList;

Questa dichiarazione specifica una lista di valori non nulli di tipo String.

conversione di tipo

newStr = (@NonNull String) str;

sintassi extends e implements

class Warning extends @Localized Message

throws sintassi

public String readMethod() throws @Localized IOException

I tipi di annotazione migliorano l'analisi del codice Java, fornendo un controllo di tipo più potente.

Tipi di annotazione

1. Annotazioni predefinite

@Deprecated
@Override
@SuppressWarnings
@SafeVarargs
@FunctionalInterface

2. Meta-annotazioni

@Retention
@Documented
@Target
@Inherited
@Repeatable

3. Annotazioni personalizzate

Questi tipi di annotazione sonoTipi di annotazione JavaDescrizione dettagliata nel tutorial.

Uso delle annotazioni

Istruzioni del compilatore - Puoi fornire istruzioni al compilatore, rilevare errori o disabilitare avvisi. Ad esempio, gli annotazioni integrati @Deprecated, @Override, @SuppressWarnings.
Istruzioni di compilazione - Questi commenti forniscono istruzioni di compilazione che aiutano gli strumenti di costruzione software a generare codice, file XML, ecc.
Istruzioni di esecuzione - Definire alcune annotazioni per fornire istruzioni al programma durante l'esecuzione. Queste annotazioni sono accessibili tramite reflection Java.

Sovraccarico di metodi Java try-with-resources Java