Annotations en Java : types, utilisations et exemples

Une annotation dans un langage de programmation tel que Java fait référence aux métadonnées syntaxiques qui peuvent être intégrées au code source de Java. Divers facteurs tels que les packages Java, les variables, les classes, les paramètres et les méthodes peuvent être annotés. Les développeurs peuvent facilement lire les annotations Java directement à partir des fichiers source, tout comme les balises Javadoc.

Les annotations Java peuvent également être incluses et lues à partir des fichiers de classe Java de sortie du compilateur Java. Cela permet à la machine virtuelle Java de conserver les annotations et de les lire via une réflexion au moment de l'exécution. En Java, il est possible de construire des méta-annotations à partir de celles existantes.

Voici quelques notions de base sur les annotations en Java :

1. Les annotations commencent toujours par un '@'. Par exemple : '@override', '@target', '@SuppressWarnings', etc.
2. Les annotations n'affectent pas le comportement d'un programme compilé.
3. Les annotations aident à associer des métadonnées à des composants de programme tels que des méthodes, des classes, des variables, etc.
4. Les annotations ne sont pas que des commentaires puisqu'elles peuvent affecter la façon dont un programme est traité par le compilateur. Ils offrent des informations de compilateur supplémentaires sur le programme mais ne font pas partie du programme lui-même. Par conséquent, ces annotations n'affectent pas l'exécution du programme compilé.

Types d'annotations en Java

1. Annotations de valeur unique

Les annotations à valeur unique n'autorisent qu'une seule forme abrégée car elles ne contiennent qu'un seul membre. Le membre doit recevoir une valeur post-application de l'annotation. Cependant, le nom de l'annotation n'a pas besoin d'être spécifié. Le membre doit avoir une valeur si le raccourci doit être utilisé. Par exemple:

@TestAnnotation("test");

2. Annotations complètes

Les annotations complètes se composent de diverses données telles que les membres de données, les valeurs, les paires et les noms.

Par exemple:

@TestAnnotation(owner=”Rahul”, value=”Class Geeks”)

Apprenez des cours de développement de logiciels en ligne dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.

3. Annotations répétitives

Lorsqu'une annotation peut être appliquée plusieurs fois à des objets singuliers, elle est étiquetée comme une annotation répétitive. Les annotations répétitives sont spécifiées avec la balise @Repeatable comme défini dans le package java.lang.annotation. Son champ de valeur indique le type de conteneur de l'annotation répétée.

Le conteneur est défini comme une annotation avec un champ de valeur qui contient un tableau d'annotations répétitives. Pour construire une annotation répétée, créez d'abord l'annotation de conteneur, puis spécifiez le type d'annotation en tant qu'entrée de l'annotation @Repeatable.

Par exemple:

// Programme Java pour démontrer une annotation répétable

// Importation des classes requises

import java.lang.annotation.Annotation ;

importer java.lang.annotation.Repeatable ;

import java.lang.annotation.Retention ;

importer java.lang.annotation.RetentionPolicy ;

importer java.lang.reflect.Method ;

// Rendre l'annotation Words répétable

@Retention(RetentionPolicy.RUNTIME)

@Repeatable(MyRepeatedAnnos.class)

@interface Mots

{

String word() par défaut "Bonjour" ;

valeur int() par défaut 0 ;

}

// Créer une annotation de conteneur

@Retention(RetentionPolicy.RUNTIME)

@interface MyRepeatedAnnos

{

Mots[] valeur();

}

classe publique principale {

// Répéter les mots sur newMethod

@Words(mot = "Premier", valeur = 1)

@Words(mot = "Second", valeur = 2)

public static void newMethod()

{

Obj principal = new Main();

essayer {

Classe<?> c = obj.getClass();

// Obtenir l'annotation pour newMethod

Méthode m = c.getMethod("newMethod");

// Affiche l'annotation répétée

Annotation

= m.getAnnotation(MyRepeatedAnnos.class);

System.out.println(anno);

}

attraper (NoSuchMethodException e) {

System.out.println(e);

}

}

public static void main(String[] args) { newMethod(); }

}

La sortie finale serait : @MyRepeatedAnnos(value={@Words(value=1, word=”First”), @Words(value=2, word=”Second”)})

Explorez nos cours populaires de génie logiciel

3. Annotations des marqueurs

Les annotations de marqueur sont uniquement destinées à des fins de déclaration. Cette annotation ne contient pas non plus de membres et aucune donnée n'existe en son sein. Son seul but est de maintenir une présence en tant qu'annotation. Par exemple : @Remplacer.

4. Tapez les annotations

Ces annotations peuvent être utilisées partout où un type est utilisé. Par exemple, nous pouvons annoter le type de retour d'une méthode. Les annotations de type sont balisées avec l'annotation @Target.

Les codes qui peuvent illustrer les annotations de type sont :

// Importation des classes requises

import java.lang.annotation.ElementType ;

importer java.lang.annotation.Target ;

// Utilisation de l'annotation cible pour annoter un type

@Target(ElementType.TYPE_USE)

// Déclaration d'une annotation de type simple

@interface TypeAnnoDemo{}

// Classe principale

classe publique GFG {

// Méthode du pilote principal

public static void main(String[] args) {

// Annotation du type d'une chaîne

@TypeAnnoDemo String string = "Ce code est annoté avec une annotation de type" ;

System.out.println(string);

abc();

}

// Annotation du type de retour d'une fonction

statique @TypeAnnoDemo int abc() {

System.out.println("Le type de retour de cette fonction est annoté");

renvoie 0 ;

}

Exemples d'annotations prédéfinies

Il existe de nombreuses variétés d'annotations prédéfinies que nous avons mentionnées précédemment. Jetons un coup d'œil :

1. @Remplacer

Cette annotation de marqueur ne peut être utilisée que sur des méthodes. Toute méthode avec l'annotation @override doit remplacer une autre méthode d'une superclasse. A défaut, une erreur de compilation est déclenchée. Cela se produit car il doit s'assurer que la superclasse est réellement remplacée et pas seulement surchargée.

Le code qui peut illustrer l'annotation de remplacement est :

// Classe 1

base de classe

{

affichage vide public()

{

System.out.println("Affichage de base()");

}

public static void main(String args[])

{

Base t1 = new Dérivée();

t1.Display();

}

}

// Classe 2

// Extension au-dessus de la classe

classe Dérivée étend Base

{

@Passer outre

affichage vide public()

{

System.out.println("Affichage dérivé()");

}

}

2. @Cible

Il est uniquement destiné à être utilisé comme annotation à une autre annotation. @Target accepte un paramètre, qui doit être une constante ElementType. Le paramètre décide à quelles déclarations il peut être appliqué. L'annotation @Target peut avoir plusieurs valeurs au lieu d'une seule valeur unique. Cependant, si plusieurs valeurs doivent être déclarées, elles doivent être sous la forme d'accolades telles que : @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE}).

L'annotation @Retention peut être utilisée ici pour déterminer le statut de rétention de l'annotation. Trois facteurs affectent une annotation @Retention :

• Source : le compilateur ne tient pas compte des annotations car elles sont généralement conservées au niveau de la source.
• Runtime : Il est conservé lors de l'exécution.
• Classe : les annotations restent au moment de la compilation et sont ignorées par le programme Java.

3. @Hérité

Cette annotation ne peut être utilisée qu'à des fins de déclaration et, par conséquent, n'affecte que certaines déclarations de classe. Une annotation peut remplacer l'autre et hériter de ses propriétés. Ainsi, la superclasse peut être vérifiée si des annotations spécifiques sont absentes de la sous-classe. Cependant, si l'annotation est présente, elle obtient l'annotation @Inherited.

Par exemple:

// Classe 1

classe DeprecatedTest

{

@Déprécié

affichage vide public()

{

System.out.println("Affichage de test obsolète()");

}

}

// Classe 2

classe publique SuppressWarningTest

{

// Si nous commentons sous l'annotation, le programme génère

// Attention

@SuppressWarnings({"vérifié", "dépréciation"})

public static void main(String args[])

{

DeprecatedTest d1 = new DeprecatedTest();

d1.Affiche();

}

}

Conclusion

Ici, nous avons découvert les annotations en Java. Nous avons également découvert les types d'annotations en Java et leurs utilisations, ce qui peut aider les développeurs Java à créer facilement des programmes robustes et évolutifs.

Si vous souhaitez en savoir plus sur les concepts Java, la certification PG liée à l'emploi d'upGrad en génie logiciel est votre meilleur pari pour acquérir une compréhension complète des langages de programmation tels que Java, HTML, JS, ainsi que d'autres outils et bibliothèques de développement de logiciels.

Le programme est conçu pour les étudiants de dernière année ou les diplômés sans emploi qui cherchent à obtenir des postes de débutant dans le domaine. Le cours de 5 mois couvre la spécialisation en MERN/Cloud-Native et aide les étudiants à construire un portfolio de premier ordre en les exposant à 5 projets pratiques.

Alors, n'attendez pas. Rendez-vous sur upGrad et réservez votre place dès aujourd'hui !