Définir des annotations : éléments et valeurs par défaut
Créez des annotations personnalisées avec @interface, définissez des éléments avec des valeurs par défaut et appliquez des méta-annotations.
Définir des annotations : éléments et valeurs par défaut est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
Que sont les annotations
Les annotations sont des métadonnées appliquées aux classes, aux méthodes, aux champs ou aux paramètres. Elles ne modifient pas directement le comportement : elles fournissent des informations aux compilateurs, aux frameworks ou aux processeurs lors de l'exécution.
Déclarer une annotation avec @interface
Utilisez @interface pour déclarer une annotation personnalisée. Les éléments ressemblent à des méthodes. La valeur par défaut est indiquée avec default.
@interface Retry {
int times() default 3;
long delayMs() default 1000L;
Class<? extends Throwable>[] on() default {Exception.class};
}Appliquer l'annotation
Appliquez l'annotation à la cible. Omettez les éléments qui possèdent des valeurs par défaut. Lorsqu'un seul élément est nommé value, vous pouvez le définir sans préciser la clé.
@Retry(times = 5, delayMs = 500)
public void callExternalService() { ... }
// Single-element shorthand:
@interface Label { String value(); }
@Label("production")
public class App {}Types des éléments d'annotation
Les éléments peuvent uniquement être des types primitifs (int, long, etc.), String, Class, une enum, un autre type d'annotation ou un tableau à une seule dimension contenant l'un des éléments précédents.
@interface Config {
String host();
int port() default 8080;
LogLevel level() default LogLevel.INFO; // enum
Class<?> handler() default DefaultHandler.class;
String[] tags() default {};
}Méta-annotations : @Retention
@Retention contrôle la durée de conservation de l'annotation : SOURCE (supprimée par le compilateur), CLASS (dans le fichier .class, mais pas à l'exécution), RUNTIME (lisible par réflexion).
@Retention(RetentionPolicy.RUNTIME)
@interface Retry {
int times() default 3;
}Méta-annotations : @Target
@Target limite les endroits où l'annotation peut être appliquée. Vous pouvez indiquer plusieurs cibles.
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface Audited {
String description() default "";
}@Documented et @Inherited
@Documented inclut l'annotation dans Javadoc. @Inherited permet aux sous-classes d'hériter de l'annotation de leur classe mère (uniquement pour les annotations appliquées au niveau d'une classe).
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Category {
String value();
}Annotations @Repeatable
Marquez une annotation avec @Repeatable pour permettre son apparition plusieurs fois sur le même élément. Fournissez une annotation conteneur qui contient un tableau.
@Repeatable(Tags.class)
@interface Tag { String value(); }
@interface Tags { Tag[] value(); }
@Tag("fast")
@Tag("stable")
public class Service {}Valeurs par défaut et omission d'éléments
Les éléments ayant des valeurs default n'ont pas besoin d'être indiqués lors de l'appel. Les éléments sans valeur par défaut sont obligatoires.
@Retry // uses defaults: times=3, delayMs=1000
public void action1() {}
@Retry(times=1) // overrides only times; delayMs stays 1000
public void action2() {}Annotation ou interface marqueur
Les interfaces marqueurs (comme Serializable) sont vérifiées avec instanceof et transmettent des informations de type. Les annotations sont plus flexibles : elles transportent des métadonnées et peuvent comporter des éléments.
Annotations intégrées courantes
Vous devez connaître les annotations du JDK : @Override, @Deprecated, @FunctionalInterface, @SuppressWarnings et @SafeVarargs.
@Override
public String toString() { return "User{" + name + "}"; }
@Deprecated(since = "2.0", forRemoval = true)
public void oldMethod() {}Vérification rapide
Quelle est la seule politique de conservation qui rend une annotation lisible à l'exécution ?
Récapitulatif
Déclarez les annotations avec @interface. Utilisez @Retention(RUNTIME) pour le traitement par réflexion, @Target pour limiter l'utilisation et default pour les éléments facultatifs. @Repeatable permet d'empiler les annotations.
Apprends Java avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 104
- Leçons
- 374
Questions Fréquemment Posées
La leçon « Définir des annotations : éléments et valeurs par défaut » est-elle gratuite ?
Oui — le texte complet de « Définir des annotations : éléments et valeurs par défaut » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Définir des annotations : éléments et valeurs par défaut » ?
Créez des annotations personnalisées avec @interface, définissez des éléments avec des valeurs par défaut et appliquez des méta-annotations. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Définir des annotations : éléments et valeurs par défaut » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Définir des annotations : éléments et valeurs par défaut
- Politiques de rétention et types de cibles
- Traitement des annotations à l’exécution
- Processeurs d’annotations à la compilation