Qu'est-ce qu'une annotation :
L'annotation (annotation) est un moyen et une méthode fournis par Java pour associer toute information et toute métadonnée (métadonnées) aux éléments du métaprogramme. L'annotation (annotation) est une interface. Le programme peut obtenir l'objet Annotation de l'élément de programme spécifié par réflexion, puis obtenir les métadonnées dans l'annotation via l'objet Annotation.
L'annotation (annotation) est introduite dans JDK5.0 et les versions ultérieures. Il peut être utilisé pour créer de la documentation, suivre les dépendances dans votre code et même effectuer des vérifications de base au moment de la compilation. D'une certaine manière, les annotations sont utilisées comme des modificateurs et sont appliquées à la déclaration des packages, des types, des constructeurs, des méthodes, des variables membres, des paramètres et des variables locales. Ces informations sont stockées dans la paire de structures "nom=valeur" de l'annotation.
Les membres d'une Annotation sont déclarés comme méthodes sans paramètre dans le type Annotation. Son nom de méthode et sa valeur de retour définissent le nom et le type du membre. Il existe ici une syntaxe par défaut spécifique : il est permis de déclarer la valeur par défaut de n'importe quel membre d'Annotation : une Annotation peut utiliser une paire nom=valeur comme valeur d'un membre d'Annotation qui ne définit pas de valeur par défaut, bien sûr, un nom. La paire =value peut également être utilisée pour remplacer la valeur par défaut des autres membres. Ceci est quelque peu similaire aux caractéristiques d'héritage des classes. Le constructeur de la classe parent peut être utilisé comme constructeur par défaut de la sous-classe, mais il peut également être remplacé par la sous-classe.
L'annotation peut être utilisée pour associer n'importe quelle information à un élément de programme (classe, méthode, variable membre, etc.). Il convient de noter qu'il existe ici une règle de base : l'annotation ne peut pas affecter l'exécution du code du programme. Peu importe si une annotation est ajoutée ou supprimée, le code sera exécuté de manière cohérente. De plus, bien que certaines annotations soient accessibles au moment de l'exécution via les méthodes de l'API de réflexion de Java, l'interpréteur du langage Java ignore ces annotations pendant son travail. C'est précisément parce que la machine virtuelle Java ignore l'annotation que le type d'annotation « ne fonctionne pas » dans le code ; les informations du type d'annotation ne sont accessibles et traitées que via certains outils de support. Cet article couvrira les types d'annotations et de méta-annotations standard. L'outil qui accompagne ces types d'annotations est le compilateur Java (qui les gère bien sûr d'une manière spéciale).
-------------------------------------------------- ----------------------------------
Qu'est-ce que les métadonnées (métadonnées) :
Les métadonnées sont traduites du mot métadonnées, qui signifie « données sur les données ».
Les métadonnées ont de nombreuses fonctions. Par exemple, vous avez peut-être utilisé des commentaires Javadoc pour générer automatiquement de la documentation. Il s'agit d'un type de fonction de métadonnées. En général, les métadonnées peuvent être utilisées pour créer de la documentation, suivre les dépendances du code, effectuer des vérifications de format au moment de la compilation et remplacer les fichiers de configuration existants. Si nous voulons classer le rôle des métadonnées, il n'existe actuellement pas de définition claire, mais nous pouvons grossièrement les diviser en trois catégories en fonction de leur rôle :
1. Rédaction de documents : Générer des documents grâce aux métadonnées identifiées dans le code 2. Analyse du code : Analyser le code grâce aux métadonnées identifiées dans le code 3. Vérification de la compilation : En utilisant les métadonnées identifiées dans le code, le compilateur peut réaliser une compilation de base Vérifier que les métadonnées en Java existent dans le code Java sous forme de balises. L'existence de balises de métadonnées n'affecte pas la compilation et l'exécution du code du programme. Elle est uniquement utilisée pour générer d'autres fichiers ou pour connaître le code exécuté au moment de l'exécution. information.
En résumé:
Premièrement, les métadonnées existent dans le code Java sous forme de balises.
Deuxièmement, les informations décrites par les métadonnées sont de type sécurisé, c'est-à-dire que les champs des métadonnées ont des types clairs.
Troisièmement, les métadonnées nécessitent un traitement supplémentaire par des outils autres que le compilateur utilisé pour générer d'autres composants du programme.
Quatrièmement, les métadonnées ne peuvent exister qu'au niveau du code source Java, ou elles peuvent exister dans le fichier Class compilé.
-------------------------------------------------- ----------------------------------
Annotations et types d'annotations :
Annotation:
L'annotation utilise la nouvelle syntaxe introduite dans java5.0 et son comportement est très similaire aux modificateurs tels que public et final. Chaque annotation a un nom et un nombre de membres >=0. Chaque membre d'une annotation a un nom et une valeur appelés une paire nom=valeur (tout comme un javabean), et nom=valeur charge les informations d'annotation.
Type d'annotation :
Le type d'annotation définit le nom, le type et la valeur par défaut du membre de l'annotation. Un type Annotation peut être considéré comme une interface Java spéciale. Ses variables membres sont restreintes et une nouvelle syntaxe est requise lors de la déclaration d'un type Annotation. Lorsque nous accédons à Annotation via l'API de réflexion Java, la valeur de retour sera un objet qui implémente l'interface de type d'annotation. En accédant à cet objet, nous pouvons facilement accéder à ses membres Annotation. Les chapitres suivants mentionneront les trois types d'annotations standard inclus dans le package java.lang de java5.0.
-------------------------------------------------- ----------------------------------
Catégories d'annotations :
Selon le nombre de paramètres d'annotation, nous pouvons diviser les annotations en trois catégories :
1. Annotation de marque : un type d'annotation sans définition de membre est appelé annotation de marque. Ce type d'annotation utilise uniquement sa propre présence ou absence pour nous fournir des informations. Par exemple, l'annotation système suivante @Override;
2. Annotation à valeur unique 3. Annotation complète
Selon l'utilisation et le but des annotations, nous pouvons diviser les annotations en trois catégories :
1. Annotations système intégrées au JDK 2. Méta-annotations 3. Annotations personnalisées
-------------------------------------------------- ----------------------------------
Annotations standard intégrées au système :
La syntaxe des annotations est relativement simple. À l'exception de l'utilisation du symbole @, elle est fondamentalement cohérente avec la syntaxe inhérente à Java. Il existe trois annotations standard intégrées à JavaSE, qui sont définies dans java.lang :
@Override : Utilisé pour modifier cette méthode pour remplacer la méthode de la classe parent ;
@Obsolète : utilisé pour modifier les méthodes obsolètes ;
@SuppressWarnings : utilisé pour avertir le compilateur Java de supprimer les avertissements de compilation spécifiques.
Examinons tour à tour les fonctions et les scénarios d'utilisation des trois annotations standard intégrées.
-------------------------------------------------- ----------------------------------
@Override, limite le remplacement des méthodes de classe parent :
@Override est un type d'annotation de marqueur utilisé pour annoter les méthodes. Cela montre que la méthode annotée surcharge la méthode de la classe parent et joue le rôle d'assertion. Si nous utilisons ce type d'annotation dans une méthode qui ne remplace pas la méthode de la classe parent, le compilateur Java vous avertira avec une erreur de compilation. Cette annotation entre souvent en jeu lorsque nous essayons de remplacer une méthode de classe parent mais que nous écrivons un mauvais nom de méthode. L'utilisation est extrêmement simple : lors de l'utilisation de cette annotation, il suffit d'ajouter @Override devant la méthode modifiée. Le code suivant est un exemple d'utilisation de @Override pour modifier la méthode displayName() d'une tentative de remplacement de la classe parent, mais il y a des erreurs d'orthographe :
public void displayName(){
System.out.println("Le nom du fruit est : *****");
}
}
la classe Orange étend Fruit {
@Outrepasser
public void displayName(){
System.out.println("Le nom du fruit est : orange");
}
}
la classe Apple étend Fruit {
@Outrepasser
nom d'affichage public void(){
System.out.println("Le nom du fruit est : Pomme");
}
}
@Obsolète, la balise est obsolète :
De même, Deprecated est également une annotation de balisage. Lorsqu'un type ou un membre de type est décoré avec @Deprecated, le compilateur découragera l'utilisation de cet élément de programme annoté. Et ce type de modification a un certain degré de « continuité » : si nous utilisons ce type ou ce membre obsolète dans le code par héritage ou écrasement, bien que le type ou le membre hérité ou remplacé ne soit pas déclaré @Deprecated, le compilateur doit toujours avertir toi.
Il est à noter qu'il existe une différence entre le type d'annotation @Deprecated et la balise @deprecated dans javadoc : le premier est reconnu par le compilateur java, tandis que le second est reconnu par l'outil javadoc et utilisé pour générer de la documentation (y compris pourquoi le programme les membres sont obsolètes et sa description de la manière dont ils devraient être interdits ou remplacés).
Dans Java 5.0, le compilateur Java recherche toujours les balises Javadoc @deprecated et les utilise pour générer des messages d'avertissement comme il le faisait dans les versions précédentes. Mais cette situation changera dans les versions ultérieures, et nous devrions commencer à utiliser @Deprecated maintenant pour décorer les méthodes obsolètes au lieu de la balise javadoc @deprecated.
Dans le programme suivant, l'annotation @Deprecated est utilisée pour marquer la méthode comme expirée. En même temps, la balise @deprecated est utilisée dans l'annotation de la méthode pour marquer la méthode comme expirée. Le code est le suivant :
/**
* @deprecated Cette méthode a expiré et n'est pas recommandée.
*/
@Obsolète
public void showTaste(){
System.out.println("Le goût des pommes fruitées est : croquant et sucré");
}
public void showTaste(int typeId){
si(typeId==1){
System.out.println("Le goût de la pomme fruitée est : aigre");
}
sinon si(typeId==2){
System.out.println("Le goût des pommes fruitées est : sucré");
}
autre{
System.out.println("Le goût des pommes fruitées est : croquant et sucré");
}
}
}
classe publique FruitRun {
/**
* @param arguments
*/
public static void main (String[] arguments) {
Apple apple=nouvelle Apple();
pomme.displayName();
AppleService appleService=new AppleService();
appleService.showTaste();
appleService.showTaste(0);
appleService.showTaste(2);
}
}
-------------------------------------------------- ----------------------------------
SuppressWarnings, supprime les avertissements du compilateur :
@SuppressWarnings est utilisé pour désactiver de manière sélective les avertissements du compilateur pour les classes, les méthodes, les variables membres et l'initialisation des variables. Dans java5.0, le compilateur javac fourni par sun nous fournit l'option -Xlint pour permettre au compilateur de mettre en garde contre le code de programme légal. Cet avertissement représente dans une certaine mesure une erreur de programme. Par exemple, lorsque nous utilisons une classe de collection générique sans fournir son type, le compilateur affichera un avertissement « avertissement non vérifié ». Habituellement, lorsque cela se produit, nous devons trouver le code à l’origine de l’avertissement. Si cela représente réellement une erreur, nous devons la corriger. Par exemple, si le message d'avertissement indique que l'instruction switch dans notre code ne couvre pas tous les cas possibles, nous devons alors ajouter un cas par défaut pour éviter cet avertissement.
Parfois, nous ne pouvons pas éviter cet avertissement. Par exemple, nous ne pouvons pas éviter cet avertissement non vérifié lorsque nous utilisons une classe de collection générique qui doit interagir avec un ancien code non générique. @SuppressWarning sera utile à ce moment-là. Ajoutez la modification @SuppressWarnings avant la méthode appelée pour indiquer au compilateur d'arrêter les avertissements concernant cette méthode.
SuppressWarning n'est pas une annotation de balisage. Il a un membre de type String[], la valeur de ce membre est le nom d'avertissement interdit. Pour le compilateur javac, les noms d'avertissement valides pour l'option -Xlint sont également valides pour @SuppressWarings, et le compilateur ignore les noms d'avertissement non reconnus.
La syntaxe d'annotation permet au nom de l'annotation d'être suivi de parenthèses. Dans les parenthèses se trouvent des paires nom=valeur séparées par des virgules utilisées pour attribuer des valeurs aux membres de l'annotation. Les exemples sont les suivants :
@SuppressWarnings(value={ "rawtypes", "unchecked" })
liste statique publique<Fruit> getFruitList(){
List<Fruit> fruitList=new ArrayList();
retourner la liste des fruits ;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
liste statique publique<Fruit> getFruit(){
List<Fruit> fruitList=new ArrayList();
retourner la liste des fruits ;
}
@SuppressWarnings("inutilisé")
public static void main (String[] args){
List<String> strList=new ArrayList<String>();
}
}
Une brève description des valeurs de paramètres courantes annotées par SuppressWarnings :
1.deprecation : avertissement lorsque des classes ou des méthodes obsolètes sont utilisées ;
2. non coché : Avertissement lorsqu'une conversion non cochée est effectuée, par exemple, lors de l'utilisation d'une collection, les génériques ne sont pas utilisés pour spécifier le type de collection enregistrée ;
3.fallthrough : avertissement lorsque le bloc du programme Switch mène directement à la situation suivante sans interruption ;
4.path : avertissement lorsqu'il existe des chemins inexistants dans le chemin de classe, le chemin du fichier source, etc. ;
5.serial : avertissement lorsque la définition de serialVersionUID est manquante sur une classe sérialisable ;
6.finally : avertissement lorsqu'une clause final ne peut pas être complétée normalement ;
7.all : Avertissement concernant toutes les situations ci-dessus.