Les annotations en Java : une explication détaillée
Les annotations en Java permettent d'ajouter des métadonnées au code source, qui
peuvent être utilisées par le compilateur, des outils ou même par le programme au
moment de l'exécution. Voici une explication pas à pas, pour tout comprendre sur les
annotations en Java.
1. Qu'est-ce qu'une annotation en Java ?
Une annotation est une forme de métadonnée qui fournit des informations
supplémentaires sur le code. Contrairement aux commentaires, elles sont accessibles au
moment de l'exécution et peuvent influencer le comportement d'un programme ou d'un
outil.
Exemple de base :
@Override
public String toString() {
return "Exemple";
Ici, @Override est une annotation qui indique au compilateur qu'une méthode redéfinit
(override) une méthode de la classe parente.
2. Pourquoi utiliser les annotations ?
Les annotations servent à :
1. Informer le compilateur : Indiquer des erreurs ou des avertissements potentiels.
o Exemple : @Override, @SuppressWarnings.
2. Configurer des frameworks : Fournir des métadonnées pour des bibliothèques ou
des frameworks comme Spring ou Hibernate.
o Exemple : @Entity, @Autowired.
3. Fournir des instructions au runtime : Via la réflexion, les annotations peuvent
modifier le comportement d'un programme.
o Exemple : @Retention, @Target.
3. Les annotations standard de Java
Voici les annotations les plus courantes fournies par Java :
3.1. Annotations de base
1. @Override : Vérifie que la méthode redéfinit une méthode de la classe parente.
@Override
public String toString() {
return "Exemple";
2. @Deprecated : Indique qu'une méthode ou classe est obsolète.
@Deprecated
public void ancienneMethode() {
[Link]("Ne pas utiliser cette méthode !");
3. @SuppressWarnings : Supprime des avertissements spécifiques du compilateur.
@SuppressWarnings("unchecked")
public void methode() {
List liste = new ArrayList(); // Pas de warning ici
3.2. Annotations spécifiques au code source
Ces annotations ne sont pas utilisées au runtime, mais elles aident le compilateur ou les
outils de développement.
1. @FunctionalInterface : Indique qu'une interface est fonctionnelle (possède une
seule méthode abstraite).
@FunctionalInterface
interface Calculateur {
int calculer(int a, int b);
2. @SafeVarargs : Supprime les avertissements concernant les varargs génériques.
@SafeVarargs
public final <T> void afficher(T... elements) {
for (T element : elements) {
[Link](element);
4. Les annotations personnalisées
En Java, on peut créer ses propres annotations. Voici les étapes détaillées.
4.1. Définir une annotation
1. Utiliser le mot-clé @interface :
public @interface MonAnnotation {
String valeur() default "par défaut";
int nombre() default 0;
2. Explication :
o Les méthodes définies dans une annotation sont des éléments qui peuvent
être configurés.
o Les valeurs par défaut sont optionnelles.
4.2. Utiliser une annotation personnalisée
Une fois définie, une annotation peut être utilisée comme ceci :
@MonAnnotation(valeur = "Exemple", nombre = 5)
public class MaClasse {
4.3. Configurer une annotation
Les annotations peuvent être configurées avec des méta-annotations, qui sont elles-
mêmes des annotations utilisées pour définir le comportement d'autres annotations.
1. @Retention : Définit si l'annotation est disponible :
o SOURCE : Accessible uniquement pendant la compilation.
o CLASS : Accessible jusqu'au bytecode (fichier .class).
o RUNTIME : Accessible au runtime via la réflexion.
Exemple :
@Retention([Link])
public @interface MonAnnotation {
2. @Target : Indique les éléments sur lesquels l'annotation peut être appliquée.
o [Link] : Appliquer sur une méthode.
o [Link] : Appliquer sur un champ.
o [Link] : Appliquer sur une classe, interface ou énumération.
Exemple :
@Target({[Link], [Link]})
public @interface MonAnnotation {
3. @Inherited : Permet à une annotation d'être héritée par les sous-classes.
@Inherited
@Retention([Link])
public @interface MonAnnotation {
5. Exemple pratique : Annotations avec réflexion
Voici un exemple complet où une annotation personnalisée est utilisée avec la réflexion.
Définir une annotation
import [Link];
import [Link];
import [Link];
import [Link];
@Retention([Link])
@Target([Link])
public @interface Info {
String auteur();
String date();
Utiliser l'annotation
public class Exemple {
@Info(auteur = "Alice", date = "2025-01-06")
public void afficher() {
[Link]("Méthode annotée !");
Lire l'annotation avec la réflexion
import [Link];
public class Main {
public static void main(String[] args) throws Exception {
Class<?> clazz = [Link];
// Parcourir les méthodes
for (Method method : [Link]()) {
// Vérifier si l'annotation est présente
if ([Link]([Link])) {
// Obtenir l'annotation
Info info = [Link]([Link]);
// Afficher les valeurs
[Link]("Méthode : " + [Link]());
[Link]("Auteur : " + [Link]());
[Link]("Date : " + [Link]());
Sortie :
Méthode : afficher
Auteur : Alice
Date : 2025-01-06
6. Avantages et inconvénients des annotations
Avantages :
1. Lisibilité : Rend la configuration plus concise que l'utilisation de XML ou de code.
2. Dynamisme : Permet d'ajouter des comportements dynamiques.
3. Interopérabilité : Utilisé largement dans des frameworks modernes (Spring,
Hibernate).
Inconvénients :
1. Couplage : Les annotations dans le code source peuvent le coupler avec un
framework particulier.
2. Complexité : Peut rendre le code difficile à lire si les annotations sont nombreuses.
3. Performance : Utiliser les annotations au runtime (avec la réflexion) peut être
coûteux.