Dans ce didacticiel, nous allons apprendre ce que sont les annotations, les différentes annotations Java et comment les utiliser à l'aide d'exemples.
Les annotations Java sont des métadonnées (données sur les données) pour le code source de notre programme.
Ils fournissent des informations supplémentaires sur le programme au compilateur mais ne font pas partie du programme lui-même. Ces annotations n'affectent pas l'exécution du programme compilé.
Les annotations commencent par @. Sa syntaxe est:
@AnnotationName
Prenons un exemple d' @Overrideannotation.
L' @Overrideannotation spécifie que la méthode qui a été marquée avec cette annotation remplace la méthode de la superclasse avec le même nom de méthode, le même type de retour et la même liste de paramètres.
Il n'est pas obligatoire de l'utiliser @Overridelors de la substitution d'une méthode. Cependant, si nous l'utilisons, le compilateur donne une erreur si quelque chose ne va pas (comme un type de paramètre incorrect) lors de la substitution de la méthode.
Exemple 1: Exemple d'annotation @Override
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(); ) )
Production
Je suis un chien.
Dans cet exemple, la méthode displayInfo()est présente à la fois dans la superclasse Animal et dans la sous-classe Dog. Lorsque cette méthode est appelée, la méthode de la sous-classe est appelée à la place de la méthode de la superclasse.
Formats d'annotations
Les annotations peuvent également inclure des éléments (membres / attributs / paramètres).
1. Annotations de marqueur
Les annotations de marqueur ne contiennent pas de membres / éléments. Il n'est utilisé que pour marquer une déclaration.
Sa syntaxe est:
@AnnotationName ()
Étant donné que ces annotations ne contiennent pas d'éléments, les parenthèses peuvent être exclues. Par exemple,
@Passer outre
2. Annotations sur un seul élément
Une seule annotation d'élément contient un seul élément.
Sa syntaxe est:
@AnnotationName (elementName = "elementValue")
S'il n'y a qu'un seul élément, c'est une convention de nommer cet élément comme valeur.
@AnnotationName (value = "elementValue")
Dans ce cas, le nom de l'élément peut également être exclu. Le nom de l'élément sera valeur par défaut.
@AnnotationName ("elementValue")
3. Annotations d'éléments multiples
Ces annotations contiennent plusieurs éléments séparés par des virgules.
Sa syntaxe est:
@AnnotationName (élément1 = "valeur1", élément2 = "valeur2")
Placement des annotations
Toute déclaration peut être marquée d'une annotation en la plaçant au-dessus de cette déclaration. À partir de Java 8, les annotations peuvent également être placées avant un type.
1. Déclarations ci-dessus
Comme mentionné ci-dessus, les annotations Java peuvent être placées au-dessus des déclarations de classe, méthode, interface, champ et autres éléments de programme.
Exemple 2: Exemple d'annotation @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(); ) )
Production
Liste de mots => (programiz)
Si le programme ci-dessus est compilé sans utiliser l' @SuppressWarnings("unchecked")annotation, le compilateur compilera toujours le programme mais il donnera des avertissements comme:
Main.java utilise des opérations non contrôlées ou non sécurisées. Liste de mots => (programiz)
Nous recevons l'avertissement
Main.java utilise des opérations non contrôlées ou non sécurisées
à cause de la déclaration suivante.
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.
- Instructions d'exécution - Certaines annotations peuvent être définies pour donner des instructions au programme lors de l'exécution. Ces annotations sont accessibles à l'aide de Java Reflection.
