In questo tutorial, impareremo cosa sono le annotazioni, le diverse annotazioni Java e come usarle con l'aiuto di esempi.
Le annotazioni Java sono metadati (dati sui dati) per il codice sorgente del nostro programma.
Forniscono informazioni aggiuntive sul programma al compilatore ma non fanno parte del programma stesso. Queste annotazioni non influenzano l'esecuzione del programma compilato.
Le annotazioni iniziano con @. La sua sintassi è:
@AnnotationName
Facciamo un esempio di @Overrideannotazione.
L' @Overrideannotazione specifica che il metodo che è stato contrassegnato con questa annotazione sostituisce il metodo della superclasse con lo stesso nome di metodo, tipo restituito e elenco di parametri.
Non è obbligatorio utilizzare @Overridequando si sovrascrive un metodo. Tuttavia, se lo usiamo, il compilatore restituisce un errore se qualcosa non va (come il tipo di parametro sbagliato) durante l'override del metodo.
Esempio 1: @Override Annotation Example
class Animal ( public void displayInfo() ( System.out.println("I am an animal."); ) ) class Dog extends Animal ( @Override public void displayInfo() ( System.out.println("I am a dog."); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.displayInfo(); ) )
Produzione
Io sono un cane.
In questo esempio, il metodo displayInfo()è presente sia nella superclasse Animal che nella sottoclasse Dog. Quando viene chiamato questo metodo, viene chiamato il metodo della sottoclasse invece del metodo nella superclasse.
Formati di annotazione
Le annotazioni possono anche includere elementi (membri / attributi / parametri).
1. Annotazioni Marker
Le annotazioni dei marker non contengono membri / elementi. Viene utilizzato solo per contrassegnare una dichiarazione.
La sua sintassi è:
@AnnotationName ()
Poiché queste annotazioni non contengono elementi, le parentesi possono essere escluse. Per esempio,
@Oltrepassare
2. Annotazioni di singoli elementi
Un'annotazione di un singolo elemento contiene un solo elemento.
La sua sintassi è:
@AnnotationName (elementName = "elementValue")
Se c'è un solo elemento, è una convenzione nominare quell'elemento come valore.
@AnnotationName (value = "elementValue")
In questo caso, anche il nome dell'elemento può essere escluso. Il nome dell'elemento sarà il valore per impostazione predefinita.
@AnnotationName ("elementValue")
3. Annotazioni a più elementi
Queste annotazioni contengono più elementi separati da virgole.
La sua sintassi è:
@AnnotationName (element1 = "value1", element2 = "value2")
Posizionamento delle annotazioni
Qualsiasi dichiarazione può essere contrassegnata con annotazione posizionandola sopra tale dichiarazione. A partire da Java 8, le annotazioni possono anche essere inserite prima di un tipo.
1. Dichiarazioni di cui sopra
Come accennato in precedenza, le annotazioni Java possono essere posizionate sopra le dichiarazioni di classe, metodo, interfaccia, campo 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(); // This causes an unchecked warning wordList.add("programiz"); System.out.println("Word list => " + wordList); ) public static void main(String args()) ( wordsList(); ) )
Produzione
Elenco di parole => (programiz)
Se il programma sopra è stato compilato senza utilizzare l' @SuppressWarnings("unchecked")annotazione, il compilatore compilerà comunque il programma ma fornirà avvisi come:
Main.java utilizza operazioni non controllate o non sicure. Elenco di parole => (programiz)
Stiamo ricevendo l'avvertimento
Main.java utilizza operazioni non controllate o non sicure
a causa della seguente dichiarazione.
ArrayList wordList = new ArrayList();
This is because we haven't defined the generic type of the array list. We can fix this warning by specifying generics inside angle brackets .
ArrayList wordList = new ArrayList();
2. Type annotations
Before Java 8, annotations could be applied to declarations only. Now, type annotations can be used as well. This means that we can place annotations wherever we use a type.
Constructor invocations
new @Readonly ArrayList()
Type definitions
@NonNull String str;
This declaration specifies non-null variable str of type String to avoid NullPointerException.
@NonNull List newList;
This declaration specifies a non-null list of type String.
List newList;
This declaration specifies a list of non-null values of type String.
Type casts
newStr = (@NonNull String) str;
extends and implements clause
class Warning extends @Localized Message
throws clause
public String readMethod() throws @Localized IOException
Type annotations enable Java code to be analyzed better and provide even stronger type checks.
Types of Annotations
1. Predefined annotations
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Meta-annotations
@Retention@Documented@Target@Inherited@Repeatable
3. Custom annotations
These annotation types are described in detail in the Java Annotation Types tutorial.
Use of Annotations
- Compiler instructions - Annotations can be used for giving instructions to the compiler, detect errors or suppress warnings. The built-in annotations
@Deprecated,@Override,@SuppressWarningsare used for these purposes. - Compile-time instructions - Compile-time instructions provided by these annotations help the software build tools to generate code, XML files and many more.
- Istruzioni di runtime - Alcune annotazioni possono essere definite per fornire istruzioni al programma in fase di runtime. È possibile accedere a queste annotazioni utilizzando Java Reflection.
