Comprendre les annotations Java - Tutoriel Java @annotations

Publié: 2019-10-22
Annotations au niveau du package

Comment et où les annotations sont-elles utilisées en Java ?

Une annotation, dans le langage de programmation informatique Java, est une forme spéciale de métadonnées syntaxiques qui peuvent être ajoutées au code source Java.

Les classes, les méthodes, les variables, les paramètres et les packages peuvent être annotés. Contrairement aux balises Javadoc, les annotations Java peuvent être réfléchissantes en ce sens qu'elles peuvent être intégrées dans des fichiers de classe générés par le compilateur et peuvent être conservées par la machine virtuelle Java pour être rendues récupérables au moment de l'exécution.

Il est possible de créer des méta-annotations à partir de celles existantes en Java, ce qui rend ce concept plus sophistiqué.

Java définit un ensemble d'annotations intégrées au langage.

Comprendre les annotations Java - Crunchify Tips
Comprendre les annotations Java – Crunchify Tips

Annotations appliquées au code java :

  • @Override – Vérifie que la fonction est un remplacement. Provoque un avertissement de compilation si la fonction n'est pas trouvée dans l'une des classes parentes.
  • @Deprecated – Marque la fonction comme obsolète. Provoque un avertissement de compilation si la fonction est utilisée.
  • @SuppressWarnings – Ordonne au compilateur de supprimer les avertissements de temps de compilation spécifiés dans les paramètres d'annotation.

Annotations appliquées à d'autres annotations :

  • @Retention – Spécifie comment l'annotation marquée est stockée : que ce soit dans le code uniquement, compilée dans la classe ou disponible au moment de l'exécution via la réflexion.
  • @Documented – Marque une autre annotation à inclure dans la documentation.
  • @Target - Marque une autre annotation pour restreindre le type d'éléments Java auxquels l'annotation peut être appliquée.
  • @Inherited – Marque une autre annotation à hériter des sous-classes de la classe annotée (par défaut, les annotations ne sont pas héritées des sous-classes).

Jetons un coup d'œil à ceux-ci via des exemples d'exemples :

1) @Remplacer l'annotation :

Sa présence indique au compilateur que la méthode annotée doit remplacer une méthode de superclasse existante.

Le cas d'utilisation le plus courant pour @Override est avec les méthodes Object :

1
2
3
4
@ Override
public int hashValue ( ) {
     System . out . Println ( "This method is using @Override Annotation" ) ;
}

La principale raison pour laquelle @Override a été créé était de traiter de simples erreurs typographiques .

Par exemple, une méthode déclarée par erreur comme

1
public int hashvalue ( ) { . . . }

n'est en fait pas un remplacement - le nom de la méthode n'a que des lettres minuscules , il ne correspond donc pas exactement au nom de la méthode hashValue() . Il compilera cependant parfaitement bien. Une telle erreur est facile à commettre et difficile à attraper, ce qui est une combinaison dangereuse. L'utilisation de l'annotation @Override vous empêche de faire de telles erreurs.

Vous devriez avoir l'habitude d'utiliser @Override chaque fois que vous remplacez une méthode de superclasse.

Comprendre les annotations Java

2) @Annotation obsolète :

Cette annotation indique que l'élément marqué est obsolète et ne doit plus être utilisé. Le compilateur génère un avertissement chaque fois qu'un programme utilise une méthode, une classe ou un champ avec l'annotation @Deprecated .

Lorsqu'un élément est obsolète, il doit également être documenté à l'aide de la balise Javadoc @deprecated , comme illustré dans l'exemple suivant.

1
2
3
4
< strong > @ Deprecated < / strong >
static void deprecatedMethod ( ) {
     System . out . Println ( "This method is Deprecated.." ) ;
}

3) Annotation @SuppressWarnings :

Dites simplement au compilateur, s'il vous plaît ne criez pas. Je sais ce que je fais .

1
2
3
4
@ SuppressWarnings ( "serial" )
public class OldCode implements Serializable {
System . out . Println ( "This is Old Code.." ) ;
}

4) @Annotation de rétention :

L'annotation de rétention indique où et pendant combien de temps les annotations de ce type doivent être conservées.

Il y a trois valeurs :

  • RetentionPolicy.SOURCE —Les annotations de ce type seront conservées uniquement au niveau de la source et seront ignorées par le compilateur.
  • RetentionPolicy.CLASS —Les annotations de ce type seront conservées par le compilateur au moment de la compilation, mais seront ignorées par la machine virtuelle.
  • RetentionPolicy.RUNTIME —Les annotations de ce type seront conservées par la machine virtuelle afin qu'elles puissent être lues uniquement au moment de l'exécution.
1
2
3
4
@ Retention ( RetentionPolicy . RUNTIME )
public @ interface Crunchify_Retention {
   String returnSomething ( ) ;
}

5) @Annotation documentée :

1
2
3
4
@ Documented
public @ interface Crunchify_Documented {
   String writeDocument ( ) ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DocumentedAnnotations {
   public static void main ( String arg [ ] ) {
       new DocumentedAnnotations ( ) . performRetention ( ) ;
       new DocumentedAnnotations ( ) . performDocumented ( ) ;
   }
   @ Crunchify_Retention ( returnSomething = "Hello retention test" )
   public void performRetention ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Retention'" ) ;
   }
   @ Crunchify_Documented ( writeDocument = "Hello document" )
   public void performDocumented ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Documented'" ) ;
   }
}

Essayez maintenant d'exécuter la commande Java Doc et de voir la sortie.

6) @Annotation cible :

La cible indique quel(s) élément(s) de programme peut(vent) être annoté(s) à l'aide d'instances du type d'annotation annotée. La valeur de Target est l'un des membres de l'énumération java.lang.annotation.ElementType :

  1. ANNOTATION_TYPE. Le type d'annotation annotée peut être utilisé pour annoter la déclaration de type d'annotation.
  2. CONSTRUCTEUR. Le type d'annotation annotée peut être utilisé pour annoter la déclaration du constructeur.
  3. CHAMP. Le type d'annotation annotée peut être utilisé pour annoter la déclaration de champ.
  4. VARIABLE LOCALE. Le type d'annotation annotée peut être utilisé pour annoter la déclaration de variable locale.
  5. MÉTHODE. Le type d'annotation annotée peut être utilisé pour annoter la déclaration de méthode.
  6. EMBALLER. Le type d'annotation annotée peut être utilisé pour annoter les déclarations de package.
  7. PARAMÈTRE. Le type d'annotation annotée peut être utilisé pour annoter les déclarations de paramètres.
  8. TAPER. Le type d'annotation annotée peut être utilisé pour annoter les déclarations de type.
1
2
3
4
@ Target ( value = METHOD )
You can have multiple values in the Target annotation .
 
@ Target ( value = { TYPE , FIELD , METHOD , PARAMETER , CONSTRUCTOR , LOCAL_VARIABLE } )

7) @Annotation héritée :

Exactement comme son nom l'indique, un type d'annotation @Inherited est hérité par les sous-classes d'un type annoté.

1
2
3
4
5
6
7
8
9
10
@ Inherited
@ interface ForEveryone { }
 
@ interface JustForMe { }
 
@ ForEveryone
@ JustForMe
class Superclass { }
 
class Subclass extends Superclass { }

Dans cet exemple, Superclass a été explicitement annoté avec @ForEveryone et @JustForMe . Subclass n'a pas été explicitement marquée avec l'un ou l'autre ; cependant, il hérite @ForEveryone car ce dernier est annoté avec @Inherited .

@JustForMe n'est pas annoté, il n'est donc pas hérité par Subclass .

Voici des annotations au niveau de la classe

Annotations au niveau de la classe