Annotations Java simples
Il n'existe que trois types d'annotations simples fournis par JDK5. Ces trois types sont utilisés pour éviter les erreurs ou fournir des rappels, à savoir :
1. Remplacer
2.Obsolète
3. Supprimer les avertissements
Il est important de noter que JDK5 (un autre terme, Tiger) n'a pas réellement de nombreuses annotations intégrées, mais il permet au noyau Java de prendre en charge la capacité des fonctionnalités d'annotation. Il est strictement indiqué dans JSR-175 qu'il est utilisé pour. définir les fonctions de métadonnées.Il doit être écrit par le programmeurTypes d'annotations personnalisés, d'autres normes JSR ont également écrit une série de types d'annotations standard.Ce qui suit utilisera des exemples pour expliquer ces trois annotations simples en profondeur.
Remplacer l'annotation
L'annotation Override indique que la méthode annotée doit remplacer la méthode de la super classe.
Si une méthode utilise cette annotation mais ne remplace pas la méthode dans la superclasse (par exemple, la capitalisation est incorrecte, ou les paramètres sont incorrects, ou la méthode est définie par la sous-classe elle-même), le compilateur générera une erreur.
(Remarque : les annotations de remplacement ne peuvent pas être utilisées dans JRE5 lors de l'implémentation de méthodes dans les interfaces. JRE6 le permet. Plusieurs fois, JRE5 signalera cette erreur).
L'exemple 1 illustre le remplacement des annotations :
Exemple d'annotation Java 1 :
Copiez le code comme suit :
classe publique Test_Override {
@Outrepasser
chaîne publique versChaîne() {
return super.toString() + "Test en utilisant l'annotation 'Override'" ;
}
}
Que se passe-t-il si le nom de la méthode est mal orthographié ? Par exemple, si vous renommez la méthode toString en "tostring" (tout en minuscules), vous recevrez un message d'erreur similaire au suivant lors de la compilation :
Copiez le code comme suit :
Compilation de 1 fichier source dans le dossier D: tempNew (2)
TestJavaApplication1buildclasses
D: tempNouveau dossier (2) TestJavaApplication1srctest
myannotationTest_Override.java:24 : la méthode ne remplace pas
une méthode de sa superclasse
@Outrepasser
1 erreur
ÉCHEC DE LA CONSTRUCTION (durée totale : 0 seconde)
Bien sûr, Eclipse signalera directement une croix rouge. Maintenant que les IDE sont devenus très simples à utiliser, les débutants ne devraient pas jouer avec la ligne de commande du JDK.
Annotation obsolète
Cette annotation indique que le compilateur doit afficher un message d'avertissement si le programme appelle un élément obsolète (Obsolète, obsolète, obsolète). L'exemple 2 montre comment utiliser l'annotation Deprecated.
Exemple d'annotation Java 2
Tout d’abord, créez une classe et marquez une méthode comme obsolète comme ceci :
Copiez le code comme suit :
classe publique Test_Deprecated {
@Obsolète
public void doSomething() {
System.out.println("Test en utilisant une annotation obsolète : 'Obsolète'");
}
}
Ensuite, essayez d'appeler cette méthode depuis une autre classe :
Copiez le code comme suit :
classe publique TestAnnotations {
public static void main (String arg[]) lève une exception {
new TestAnnotations();
}
public TestAnnotations() {
Test_Deprecated t2=nouveau Test_Deprecated();
t2.doSomething();
}
La méthode doSomething() dans cet exemple est déclarée comme méthode obsolète. Par conséquent, cette méthode ne doit pas être appelée dans des circonstances normales. Il n'y aura pas de message d'avertissement lors de la compilation du fichier Test_Deprecated.java. Mais lors de la compilation de TestAnnotations.java. Un message d'avertissement similaire à celui-ci sera donné (Eclipse avertira) :
Copiez le code comme suit :
Compilation de 1 fichier source dans le dossier D: tempNew
(2)TestJavaApplication1buildclasses
D:tempNouveau dossier
(2) TestJavaApplication1srctestmyannotation
TestAnnotations.java:27 :
avertissement : [dépréciation] doSomething() dans
test.myannotation.Test_Deprecated est obsolète
t2.doSomething();
1 avertissement
Supprimer l'annotation des avertissements
Cette annotation indique au compilateur que les messages d'avertissement pour l'élément annoté et tous les sous-éléments doivent être supprimés. Tous les messages d'avertissement pour un ensemble d'éléments et de sous-éléments seront supprimés. Par exemple, supposons que vous utilisiez l'annotation Suppresswarnings sur une classe pour. supprimer un avertissement. Si vous utilisez l'annotation Suppresswarnings sur une méthode pour supprimer un autre avertissement, les deux avertissements seront supprimés au niveau de la méthode.
Exemple d'annotation Java 3 :
Copiez le code comme suit :
classe publique TestAnnotations {
public static void main (String arg[]) lève une exception {
new TestAnnotations().doSomeTestNow();
}
@SuppressWarnings({"obsolescence"})
public void doSomeTestNow() {
Test_Deprecated t2 = new Test_Deprecated();
t2.doSomething();
}
}
Dans cet exemple, @SuppressWarnings est utilisé pour supprimer le message d'avertissement de dépréciation présenté dans l'exemple 2. Étant donné que ce type d'avertissement pour cette méthode est supprimé, vous ne verrez plus l'avertissement « dépréciation ».
Remarque : Il est préférable d'utiliser cette annotation sur l'élément le plus interne. Par conséquent, si vous souhaitez uniquement supprimer un avertissement sur une méthode spécifique, vous devez l'annoter sur la méthode plutôt que d'utiliser l'annotation sur la classe.
Méta-annotations (type d'annotation Java)
Les méta-annotations, en fait appelées annotations, comprennent quatre types :
1.Cible
2. Rétention
3.Documenté
4. Hérité
Annotation cible
L'annotation Target indique à quel élément cible le type d'annotation s'applique. Elle contient les valeurs de type d'énumération suivantes :
1.@Target(ElementType.TYPE)--peut être appliqué aux éléments de n'importe quelle classe
2.@Target(ElementType.FIELD) - s'applique uniquement aux champs ou aux propriétés
3.@Target(ElementType.METHOD) - applicable uniquement aux annotations de méthode
4.@Target(ElementType.PARAMETER) - s'applique uniquement aux paramètres de méthode
5.@Target(ElementType.CONSTRUCTOR)--applicable uniquement aux constructeurs
6.@Target(ElementType.LOCAL_VARIABLE)--applicable uniquement aux variables locales
7.@Target(ElementType.ANNOTATION_TYPE)——Indique que le type déclaré lui-même est un type d'annotation
L'exemple 4 illustre l'annotation Target :
Exemple d'annotation Java 4
Tout d'abord, un type d'annotation nommé Test_Target est défini, avec la méta-annotation @Target, comme indiqué ci-dessous :
Copiez le code comme suit :
@Target (ElementType.METHOD)
public @interface Test_Target {
public String doTestTarget();
}
Créez ensuite une classe qui sera annotée avec Test_Target :
Copiez le code comme suit :
classe publique TestAnnotations {
public static void main(String arg[]) {
new TestAnnotations().doTestTarget();
}
// Utiliser des annotations sur les méthodes, OK.
// Il ne peut y avoir aucun saut de ligne au milieu, 2 lignes, etc. Java ignore les sauts de ligne redondants.
@Test_Target(doTestTarget="Bonjour tout le monde !")
public void doTestTarget() {
System.out.printf("Test de l'annotation cible");
}
}
L'annotation @Target(ElementType.METHOD) indique que le type d'annotation ne peut être utilisé que pour annoter des méthodes. Si vous compilez ce code, aucun message d'avertissement ne sera affiché. Cependant, que se passera-t-il si cette annotation est déclarée sur une variable chaîne ? Quoi ? Comme ça :
Copiez le code comme suit :
classe publique TestAnnotations {
// C'est une mauvaise approche et la compilation échouera car l'annotation est au mauvais niveau.
// Les méta-annotations indiquent que seules les méthodes peuvent être annotées et qu'elles ne peuvent pas être utilisées pour annoter des propriétés.
@Test_Target(doTestTarget="Bonjour tout le monde !")
chaîne de chaîne privée ;
public static void main(String arg[]) {
new TestAnnotations().doTestTarget();
}
public void doTestTarget() {
System.out.printf("Test de l'annotation cible");
}
}
Le seul changement est que la déclaration d'annotation passe du niveau méthode au niveau champ, ce qui est incorrect. Étant donné que vous avez défini l'annotation @Test_Target ne s'applique qu'au niveau méthode, si vous essayez de compiler cette classe, vous risquez d'obtenir une erreur. message comme ceci :
Copiez le code comme suit :
"TestAnnotations.java" :
D:R_AND_DTestAnnotationsrctestmyannotation
TestAnnotations.java:16 :
type d'annotation non applicable à ce type de déclaration à la ligne
16, colonne 0
@Test_Target(doTestTarget="Bonjour tout le monde !")
^
Erreur dans la compilation javac