Types d'annotations Java : guide complet des annotations prédéfinies, personnalisées et méta

Types d'annotations Java

Ce tutoriel couvre les annotations Java – prédéfinies, personnalisées et méta-annotations – avec des exemples clairs.

Les annotations Java sont des métadonnées qui décrivent des éléments dans votre code source. La plateforme Java SE fournit un ensemble d'annotations standard, et les développeurs peuvent en créer de personnalisées adaptées à leurs projets. Les annotations peuvent aussi être annotées elles-mêmes, formant ce qu'on appelle des méta-annotations.

Les annotations se divisent en trois catégories :

1. Annotations prédéfinies – intégrées à la plateforme Java.
2. Annotations personnalisées – définies par l'utilisateur pour des besoins spécifiques.
3. Méta-annotations – annotations appliquées à d'autres annotations.

---

Types d'annotations prédéfinies

1. @Deprecated

Le marqueur @Deprecated signale qu'une classe, méthode, champ ou autre élément est obsolète et a une alternative plus récente. Le compilateur émet un avertissement chaque fois qu'un élément déprécié est utilisé.

Syntaxe :

@Deprecated public void oldMethod() { ... }

Javadoc fournit la balise @deprecated pour la documentation :

/** * @deprecated * Use {@link #newMethod()} instead. */ @Deprecated public void oldMethod() { ... }

Exemple

class Main { /** * @deprecated * This method is deprecated and has been replaced by newMethod() */ @Deprecated public static void deprecatedMethod() { System.out.println("Deprecated method"); } public static void main(String[] args) { deprecatedMethod(); } }

Sortie

Deprecated method

---

2. @Override

L'annotation @Override indique qu'une méthode est destinée à redéfinir une méthode d'une superclasse ou interface. Bien que non obligatoire, elle attrape les erreurs comme les signatures mal assorties à la compilation.

Exemple

class Animal { public void display() { System.out.println("I am an animal"); } } class Dog extends Animal { @Override public void display() { System.out.println("I am a dog"); } public void printMessage() { display(); } } class Main { public static void main(String[] args) { Dog dog1 = new Dog(); dog1.printMessage(); } }

Sortie

I am a dog

---

3. @SuppressWarnings

Cette annotation demande au compilateur d'ignorer des catégories d'avertissements spécifiques. Les catégories courantes incluent deprecation et unchecked.

Utilisation :

@SuppressWarnings("deprecation")

Plusieurs catégories :

@SuppressWarnings({"deprecation", "unchecked"})

Exemple

class Main { @Deprecated public static void deprecatedMethod() { System.out.println("Deprecated method"); } @SuppressWarnings("deprecation") public static void main(String[] args) { Main depObj = new Main(); depObj.deprecatedMethod(); } }

Sortie

Deprecated method

---

4. @SafeVarargs

Appliquée aux méthodes et constructeurs final, static ou private, @SafeVarargs affirme que la méthode n'effectue pas d'opérations non-sûres sur son paramètre varargs. Cela supprime les avertissements unchecked liés aux varargs.

Exemple

import java.util.*; class Main { @SafeVarargs private static void displayList(List... lists) { for (List list : lists) { System.out.println(list); } } public static void main(String[] args) { List universityList = Arrays.asList("Tribhuvan University", "Kathmandu University"); List programmingLanguages = Arrays.asList("Java", "C"); displayList(universityList, programmingLanguages); } }

Sortie

[Tribhuvan University, Kathmandu University] [Java, C]

---

5. @FunctionalInterface

Introduite en Java 8, cette annotation désigne une interface comme interface fonctionnelle – une interface avec une seule méthode abstraite. Le compilateur vérifie cette contrainte.

Exemple

@FunctionalInterface public interface MyFuncInterface { void firstMethod(); // abstract }

L'ajout d'une seconde méthode abstraite déclenche une erreur de compilation :

@FunctionalInterface public interface MyFuncInterface { void firstMethod(); void secondMethod(); // erreur de compilation }

Plusieurs méthodes default ou static sont autorisées.

@FunctionalInterface public interface MyFuncInterface { void firstMethod(); default void secondMethod() { /* ... */ } default void thirdMethod() { /* ... */ } }

---

Annotations personnalisées

Les développeurs peuvent créer des annotations adaptées aux exigences spécifiques de l'application. La syntaxe utilise @interface et peut inclure des méthodes d'élément avec des valeurs par défaut optionnelles.

Syntaxe

@interface AnnotationName { ElementType elementName() default defaultValue; }

Exemple

@interface MyCustomAnnotation { String value() default "default value"; } class Main { @MyCustomAnnotation(value = "programiz") public void method1() { System.out.println("Test method 1"); } public static void main(String[] args) { new Main().method1(); } }

Sortie

Test method 1

---

Méta-annotations

Les méta-annotations configurent le comportement d'autres annotations.

1. @Retention

Définit la portée de visibilité d'une annotation : SOURCE, CLASS ou RUNTIME.

@Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation { }

2. @Documented

Assure que l'annotation apparaît dans le Javadoc généré.

@Documented public @interface MyAnnotation { }

3. @Target

Restreint l'annotation à des éléments de programme spécifiques.

@Target(ElementType.METHOD) public @interface MyAnnotation { }

Les types d'éléments incluent ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE.

4. @Inherited

Permet à une sous-classe d'hériter d'une annotation présente sur une superclasse.

@Inherited public @interface MyAnnotation { }

5. @Repeatable

Permet à une annotation d'être appliquée plusieurs fois au même élément. Nécessite une annotation conteneur.

@Repeatable(Universities.class) public @interface University { String name(); } public @interface Universities { University[] value(); }

Utilisation :

@University(name = "TU") @University(name = "KU") private String uniName;

---

Pour accéder aux données d'annotation à l'exécution, utilisez les méthodes getAnnotationsByType() ou getAnnotations() de l'API de Réflexion.