Annotations Java
Annotations Java
Dans ce didacticiel, nous apprendrons 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 de @Override annotation.
Le @Override annotation 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 d'utiliser @Override lors du remplacement d'une méthode. Cependant, si nous l'utilisons, le compilateur génère une erreur si quelque chose ne va pas (comme un type de paramètre incorrect) lors de la redéfinition 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();
}
}
Sortie
I am a dog.
Dans cet exemple, la méthode displayInfo() est présent à la fois dans la superclasse Animal et sous-classe Chien . 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 sert uniquement à marquer une déclaration.
Sa syntaxe est :
@AnnotationName()
Comme ces annotations ne contiennent pas d'éléments, les parenthèses peuvent être exclues. Par exemple,
@Override
2. Annotations d'élément unique
Une annotation d'élément unique ne contient qu'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 value 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(element1 = "value1", element2 = "value2")
Emplacement des annotations
Toute déclaration peut être marquée d'une annotation en la plaçant au-dessus de cette déclaration. Depuis 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, de méthode, d'interface, de champ et d'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();
}
}
Sortie
Word list => [programiz]
Si le programme ci-dessus est compilé sans utiliser le @SuppressWarnings("unchecked") annotation, le compilateur compilera toujours le programme mais il donnera des avertissements comme :
Main.java uses unchecked or unsafe operations. Word list => [programiz]
Nous recevons l'avertissement
Main.java uses unchecked or unsafe operations
à cause de la déclaration suivante.
ArrayList wordList = new ArrayList<>();
C'est parce que nous n'avons pas défini le type générique de la liste de tableaux. Nous pouvons corriger cet avertissement en spécifiant les génériques entre crochets <> .
ArrayList<String> wordList = new ArrayList<>();
2. Tapez les annotations
Avant Java 8, les annotations ne pouvaient être appliquées qu'aux déclarations. Désormais, les annotations de type peuvent également être utilisées. Cela signifie que nous pouvons placer des annotations partout où nous utilisons un type.
Invocations de constructeur
new @Readonly ArrayList<>()
Définitions de type
@NonNull String str;
Cette déclaration spécifie une variable non nulle str de type String pour éviter NullPointerException .
@NonNull List<String> newList;
Cette déclaration spécifie une liste non nulle de type String .
List<@NonNull String> newList;
Cette déclaration spécifie une liste de valeurs non nulles de type String .
Type casts
newStr = (@NonNull String) str;
étend et implémente la clause
class Warning extends @Localized Message
clause de lancement
public String readMethod() throws @Localized IOException
Les annotations de type permettent une meilleure analyse du code Java et fournissent des vérifications de type encore plus solides.
Types d'annotations
1. Annotations prédéfinies
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Méta-annotations
@Retention@Documented@Target@Inherited@Repeatable
3. Annotations personnalisées
Ces types d'annotations sont décrits en détail dans le didacticiel sur les types d'annotations Java.
Utilisation des annotations
- Instructions du compilateur - Les annotations peuvent être utilisées pour donner des instructions au compilateur, détecter des erreurs ou supprimer des avertissements. Les annotations intégrées
@Deprecated,@Override,@SuppressWarningssont utilisés à ces fins. - Instructions de compilation - Les instructions de compilation fournies par ces annotations aident le logiciel à créer des outils pour générer du code, des fichiers XML et bien d'autres.
- 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.
Java