Les classes, méthodes, variables, paramètres, packages, etc. du langage Java peuvent tous être annotés. Contrairement à Javadoc, le contenu des annotations Java peut être récupéré par réflexion. Lorsque le compilateur génère des fichiers de classe, les annotations peuvent être intégrées dans le bytecode. La machine virtuelle Java peut conserver le contenu des annotations, et ce contenu peut être récupéré à l'exécution. Bien sûr, il prend également en charge les annotations Java personnalisées.
Il existe de nombreux articles en ligne sur les annotations Java, qui peuvent être éblouissants. Les annotations Java sont en fait assez simples, mais les auteurs n'ont pas réussi à les expliquer clairement, laissant les lecteurs encore plus confus.
J'ai organisé les annotations selon ma propre compréhension. La clé pour comprendre les annotations est de comprendre leur syntaxe et leur utilisation, et je les ai expliquées en détail. Après avoir compris la syntaxe et l'utilisation, regarder le diagramme du framework pourrait vous donner une compréhension plus profonde. Assez de bavardages ; commençons l'explication des annotations. Si vous trouvez des erreurs ou des lacunes dans l'article, veuillez les signaler !
Annotations intégrées
Java définit un ensemble d'annotations, 7 au total. 3 se trouvent dans java.lang, et les 4 restantes se trouvent dans java.lang.annotation.
Les annotations qui agissent sur le code sont :
- @Override - Vérifie si la méthode est une méthode de redéfinition. Si elle constate que la classe parente ou l'interface référencée ne possède pas cette méthode, une erreur de compilation est signalée.
- @Deprecated - Marque une méthode comme obsolète. Si la méthode est utilisée, un avertissement de compilation est signalé.
- @SuppressWarnings - Indique au compilateur d'ignorer les avertissements déclarés dans l'annotation.
Les annotations qui agissent sur d'autres annotations (ou méta-annotations) sont :
- @Retention - Identifie comment cette annotation est conservée : si elle est uniquement dans le code, compilée dans le fichier de classe, ou accessible via la réflexion à l'exécution.
- @Documented - Indique si ces annotations sont incluses dans la documentation utilisateur.
- @Target - Indique à quel type de membre Java cette annotation doit s'appliquer.
- @Inherited - Indique de quelle classe d'annotation cette annotation est héritée (par défaut, les annotations ne sont héritées par aucune sous-classe).
À partir de Java 7, 3 annotations supplémentaires ont été ajoutées :
- @SafeVarargs - Pris en charge à partir de Java 7, ignore les avertissements générés par les appels à des méthodes ou constructeurs qui utilisent des paramètres variables génériques.
- @FunctionalInterface - Pris en charge à partir de Java 8, identifie une fonction anonyme ou une interface fonctionnelle.
- @Repeatable - Pris en charge à partir de Java 8, indique qu'une annotation peut être utilisée plusieurs fois sur la même déclaration.
1. Architecture des annotations

À partir de cela, on peut voir :
(01) 1 Annotation est associée à 1 RetentionPolicy.
On peut le comprendre ainsi : chaque objet Annotation possède un attribut RetentionPolicy unique.(02) 1 Annotation est associée à 1~n ElementType.
On peut l'interpréter ainsi : chaque objet Annotation peut avoir plusieurs attributs ElementType.
(03) Annotation a de nombreuses classes d'implémentation, notamment : Deprecated, Documented, Inherited, Override, etc.
Chaque classe d'implémentation de Annotation est "associée à 1 RetentionPolicy" et "associée à 1~n ElementType".
Ci-dessous, je vais d'abord présenter la moitié gauche du diagramme du framework (comme illustré ci-dessous), à savoir Annotation, RetentionPolicy et ElementType ; ensuite je donnerai des exemples pour expliquer les classes d'implémentation de Annotation.

2. Composants d'Annotation
Parmi les composants des annotations Java, il y a 3 classes principales très importantes. Ce sont :
Annotation.java
public interface Annotation {
boolean equals(Object obj);
int hashCode();
String toString();
Class<? extends Annotation> annotationType();
}
ElementType.java
public enum ElementType {
TYPE, /* Classe, interface (y compris type d'annotation), ou déclaration d'énumération */
FIELD, /* Déclaration de champ (y compris constante d'énumération) */
METHOD, /* Déclaration de méthode */
PARAMETER, /* Déclaration de paramètre */
CONSTRUCTOR, /* Déclaration de constructeur */
LOCAL_VARIABLE, /* Déclaration de variable locale */
ANNOTATION_TYPE, /* Déclaration de type d'annotation */
PACKAGE /* Déclaration de paquetage */
}
RetentionPolicy.java
public enum RetentionPolicy {
SOURCE, /* Les informations d'Annotation n'existent que pendant le traitement du compilateur ; une fois le compilateur terminé, les informations d'Annotation n'existent plus */
CLASS, /* Le compilateur stocke l'Annotation dans le fichier .class correspondant à la classe. Comportement par défaut */
RUNTIME /* Le compilateur stocke l'Annotation dans le fichier de classe, et elle peut être lue par la JVM */
}
Explication :
(01) Une Annotation n'est qu'une interface.
« Chaque Annotation » est associée à « 1 RetentionPolicy » et est associée à « 1~n ElementType ». En termes simples : chaque objet Annotation possède un attribut RetentionPolicy unique ; quant à l'attribut ElementType, il y en a 1~n.
(02) ElementType est un type énuméré qui est utilisé pour spécifier le type d'une Annotation.
« Chaque Annotation » est associée à « 1~n ElementType ». Lorsqu'une Annotation est associée à un certain ElementType, cela signifie que l'Annotation a une certaine finalité. Par exemple, si un objet Annotation est de type METHOD, alors l'Annotation ne peut être utilisée que pour modifier des méthodes.
(03) RetentionPolicy est un type énuméré qui est utilisé pour spécifier la politique d'une Annotation. En termes simples, les Annotations de différents types de RetentionPolicy ont des portées différentes.
« Chaque Annotation » est associée à « 1 RetentionPolicy ».
- a) Si le type de l'Annotation est SOURCE, cela signifie : l'Annotation n'existe que pendant le traitement du compilateur ; une fois que le compilateur a terminé le traitement, l'Annotation n'est plus utile. Par exemple, le marqueur « @Override » est une Annotation. Lorsqu'il modifie une méthode, cela signifie que la méthode redéfinit une méthode de la classe parente, et une vérification syntaxique est effectuée pendant la compilation ! Après que le compilateur a terminé le traitement, « @Override » n'a plus d'effet.
- b) Si le type de l'Annotation est CLASS, cela signifie : le compilateur stocke l'Annotation dans le fichier .class correspondant à la classe. C'est le comportement par défaut de l'Annotation.
- c) Si le type de l'Annotation est RUNTIME, cela signifie : le compilateur stocke l'Annotation dans le fichier de classe, et elle peut être lue par la JVM.
À ce stade, vous devez simplement vous rappeler que « chaque Annotation » est associée à « 1 RetentionPolicy » et est associée à « 1~n ElementType ». Après avoir appris le contenu suivant, regarder à nouveau ce contenu le rendra plus facile à comprendre.
3. Annotations fournies par Java
Après avoir compris les rôles des 3 classes ci-dessus, nous pouvons maintenant expliquer les définitions syntaxiques des classes d'implémentation d'Annotation.
1) Définition générale d'Annotation
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation1 {
}
Explication :
Ce qui précède sert à définir une Annotation nommée MyAnnotation1. Après avoir défini MyAnnotation1, nous pouvons l'utiliser dans le code via "@MyAnnotation1". Les autres, @Documented, @Target, @Retention, @interface, sont tous utilisés pour modifier MyAnnotation1. Ci-dessous, expliquons leurs significations respectives :
(01) @interface
Lorsqu'on utilise @interface pour définir une annotation, cela signifie qu'elle implémente l'interface java.lang.annotation.Annotation, c'est-à-dire que l'annotation est une Annotation.
Lors de la définition d'une Annotation, @interface est requis.Remarque : Ceci est différent de notre façon habituelle d'implémenter des interfaces avec "implements". Les détails d'implémentation de l'interface Annotation sont tous effectués par le compilateur. Après avoir défini une annotation avec @interface, l'annotation ne peut pas hériter d'autres annotations ou interfaces.
(02) @Documented
Par défaut, les Annotations sur les classes et les méthodes n'apparaissent pas dans javadoc. Si l'Annotation est modifiée avec @Documented, cela signifie qu'elle peut apparaître dans javadoc.
Lors de la définition d'une annotation, @Documented est facultatif ; s'il n'est pas défini, l'annotation n'apparaîtra pas dans javadoc.
(03) @Target(ElementType.TYPE)
Précédemment, nous avons dit qu'ElementType est l'attribut de type d'une annotation. Et le rôle de @Target est de spécifier l'attribut de type de l'annotation.
@Target(ElementType.TYPE) signifie spécifier que le type de cette annotation est ElementType.TYPE. Cela signifie que MyAnnotation1 est une annotation utilisée pour modifier « classe, interface (y compris les types d'annotation), ou déclarations d'énumération ».
Lors de la définition d'une annotation, @Target est facultatif. S'il y a @Target, l'annotation ne peut être utilisée qu'aux endroits qu'il spécifie ; s'il n'y a pas de @Target, l'annotation peut être utilisée n'importe où.
(04) @Retention(RetentionPolicy.RUNTIME)
Précédemment, nous avons dit que RetentionPolicy est l'attribut de stratégie d'une annotation, et le rôle de @Retention est de spécifier l'attribut de stratégie de l'annotation.
@Retention(RetentionPolicy.RUNTIME) signifie spécifier que la stratégie de cette annotation est RetentionPolicy.RUNTIME. Cela signifie que le compilateur conservera les informations de l'annotation dans le fichier .class, et qu'elles pourront être lues par la machine virtuelle.
Lors de la définition d'une annotation, @Retention est facultatif. S'il n'y a pas de @Retention, la valeur par défaut est RetentionPolicy.CLASS.
2) Annotations fournies par Java
À travers les exemples ci-dessus, nous pouvons comprendre : @interface est utilisé pour déclarer une annotation, @Documented est utilisé pour indiquer si l'annotation apparaîtra dans javadoc, @Target est utilisé pour spécifier le type de l'annotation, et @Retention est utilisé pour spécifier la stratégie de l'annotation.
Après avoir compris cela, nous pouvons facilement comprendre les classes d'implémentation des annotations fournies avec Java, c'est-à-dire la moitié droite du diagramme d'architecture des annotations. Comme indiqué ci-dessous :

Annotations couramment utilisées en Java :
@Deprecated -- @Deprecated 所标注内容,不再被建议使用。 @Override -- @Override 只能标注方法,表示该方法覆盖父类中的方法。 @Documented -- @Documented 所标注内容,可以出现在javadoc中。 @Inherited -- @Inherited只能被用来标注“Annotation类型”,它所标注的Annotation具有继承性。 @Retention -- @Retention只能被用来标注“Annotation类型”,而且它被用来指定Annotation的RetentionPolicy属性。 @Target -- @Target只能被用来标注“Annotation类型”,而且它被用来指定Annotation的ElementType属性。 @SuppressWarnings -- @SuppressWarnings 所标注内容产生的警告,编译器会对这些警告保持静默。
Puisque "@Deprecated et @Override" sont similaires, et que "@Documented, @Inherited, @Retention, @Target" sont similaires ; ci-dessous, nous n'expliquerons que les trois Annotations : @Deprecated, @Inherited et @SuppressWarnings.
2.1) @Deprecated
La définition de @Deprecated est la suivante :
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Deprecated {
}
Explication :
- (01) @interface -- Il est utilisé pour modifier Deprecated, ce qui signifie que Deprecated implémente l'interface java.lang.annotation.Annotation ; c'est-à-dire que Deprecated est une annotation. (02) @Documented -- Son rôle est d'indiquer que cette annotation peut apparaître dans javadoc.
- (03) @Retention(RetentionPolicy.RUNTIME) -- Son rôle est de spécifier que la stratégie de Deprecated est RetentionPolicy.RUNTIME. Cela signifie que le compilateur conservera les informations de Deprecated dans le fichier .class, et elles pourront être lues par la machine virtuelle.
- (04) Le contenu marqué par @Deprecated n'est plus recommandé pour utilisation.
Par exemple, si une méthode est marquée avec @Deprecated, cette méthode n'est plus recommandée pour utilisation. Si un développeur essaie d'utiliser ou de redéfinir une méthode marquée avec @Deprecated, le compilateur donnera les informations d'invite correspondantes. Un exemple est le suivant :

DeprecatedTest.java
import java.util.Calendar;
public class DeprecatedTest {
// @Deprecated modifie getString1(), indiquant qu'il s'agit d'une fonction qui n'est pas recommandée pour utilisation
@Deprecated
private static void getString1(){
System.out.println("Méthode obsolète");
}
private static void getString2(){
System.out.println("Méthode normale");
}
// Date est une classe de date/heure. Java ne recommande plus d'utiliser cette classe
private static void testDate() {
Date date = new Date(113, 8, 25);
System.out.println(date.getYear());
}
// Calendar est une classe de date/heure. Java recommande d'utiliser Calendar au lieu de Date pour représenter "date/heure"
private static void testCalendar() {
Calendar cal = Calendar.getInstance();
System.out.println(cal.get(Calendar.YEAR));
}
public static void main(String[] args) {
getString1();
getString2();
testDate();
testCalendar();
}
}
Explication :
La capture d'écran ci-dessus provient d'Eclipse et compare « getString1() et getString2() » ainsi que « testDate() et testCalendar() » dans la classe.
(01) getString1() est marqué avec @Deprecated, ce qui signifie que getString1() n'est plus recommandé pour l'utilisation ; par conséquent, la définition et l'invocation de getString1() sont barrées. Ce barré correspond au traitement par Eclipse des méthodes marquées avec @Deprecated.
getString2() n'est pas marqué avec @Deprecated, donc son affichage est normal.
(02) testDate() appelle des méthodes liées à Date, mais Java a recommandé de ne pas utiliser Date pour les opérations de date/heure. Par conséquent, lors de l'appel de l'API de Date, des messages d'avertissement sont générés, à savoir les avertissements de la figure.
testCalendar() appelle l'API de Calendar pour manipuler la date/heure. Java recommande d'utiliser Calendar au lieu de Date. Par conséquent, l'utilisation de Calendar ne produira pas d'avertissement.
2.2) @Inherited
La définition de @Inherited est la suivante :
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}
Explication :
- (01) @interface -- Il est utilisé pour modifier Inherited, ce qui signifie qu'Inherited implémente l'interface java.lang.annotation.Annotation ; autrement dit, Inherited est une annotation.
- (02) @Documented -- Son rôle est d'indiquer que cette annotation peut apparaître dans javadoc.
- (03) @Retention(RetentionPolicy.RUNTIME) -- Son rôle est de spécifier que la stratégie d'Inherited est RetentionPolicy.RUNTIME. Cela signifie que le compilateur conservera les informations d'Inherited dans le fichier .class, et qu'elles pourront être lues par la machine virtuelle.
- (04) @Target(ElementType.ANNOTATION_TYPE) -- Son rôle est de spécifier que le type d'Inherited est ANNOTATION_TYPE. Cela signifie que @Inherited ne peut être utilisé que pour annoter des « types d'annotation ».
- (05) La signification de @Inherited est que l'annotation qu'il annote sera héritée.
MyAnnotation, alors Base « possède l'annotation MyAnnotation » ; maintenant, Sub hérite de Base, et comme MyAnnotation est @Inherited (possède l'héritage), Sub « possède aussi l'annotation MyAnnotation ».
Exemple d'utilisation de @Inherited:
InheritableSon.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
/**
* Annotation personnalisée.
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface Inheritable
{
}
@Inheritable
class InheritableFather
{
public InheritableFather() {
// Indique si InheritableBase possède l'annotation Inheritable
System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
}
}
/**
* La classe InheritableSon hérite simplement de InheritableFather,
*/
public class InheritableSon extends InheritableFather
{
public InheritableSon() {
super(); // Appeler le constructeur de la classe parente
// La classe InheritableSon possède l'annotation Inheritable
System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
}
public static void main(String[] args)
{
InheritableSon est = new InheritableSon();
}
}
Résultat de l'exécution :
InheritableFather:true InheritableSon:true
Maintenant, dans InheritableSon.java, mettez en commentaire l'annotation "@Inherited" de Inheritable.
InheritableSon.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
/**
* Annotation personnalisée.
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
//@Inherited
@interface Inheritable
{
}
@Inheritable
class InheritableFather
{
public InheritableFather() {
// Indique si InheritableBase possède l'annotation Inheritable
System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
}
}
/**
* La classe InheritableSon hérite simplement de InheritableFather,
*/
public class InheritableSon extends InheritableFather
{
public InheritableSon() {
super(); // Appel du constructeur de la classe parente
// La classe InheritableSon possède l'annotation Inheritable
System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
}
public static void main(String[] args)
{
InheritableSon est = new InheritableSon();
}
}
Sortie :
InheritableFather:true InheritableSon:false
En comparant les deux résultats ci-dessus, nous constatons que lorsque l'annotation Inheritable est marquée avec @Inherited, elle est héritée. Sinon, elle ne l'est pas.
2.3) @SuppressWarnings
La définition de @SuppressWarnings est la suivante :
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
String[] value();
}
Explication :
(01) @interface -- Il est utilisé pour modifier SuppressWarnings, ce qui signifie que SuppressWarnings implémente l'interface java.lang.annotation.Annotation ; c'est-à-dire que SuppressWarnings est une annotation.
(02) @Retention(RetentionPolicy.SOURCE) -- Son objectif est de spécifier que la politique de SuppressWarnings est RetentionPolicy.SOURCE. Cela signifie que les informations de SuppressWarnings n'existent que pendant le traitement du compilateur ; après que le compilateur a terminé le traitement, SuppressWarnings n'a aucun effet.
(03) @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) -- Son objectif est de spécifier que les types de SuppressWarnings incluent TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE.
- TYPE signifie qu'il peut annoter « classes, interfaces (y compris les types d'annotation), ou déclarations d'énumération ».
- FIELD signifie qu'il peut annoter « déclarations de champ ».
- METHOD signifie qu'il peut annoter « méthodes ».
- PARAMETER signifie qu'il peut annoter « paramètres ».
- CONSTRUCTOR signifie qu'il peut annoter « constructeurs ».
- LOCAL_VARIABLE signifie qu'il peut annoter « variables locales ».
(04) String[] value(); signifie que SuppressWarnings peut spécifier des paramètres.
(05) L'objectif de SuppressWarnings est de faire en sorte que le compilateur reste silencieux au sujet de certains avertissements dans le contenu qu'il annote. Par exemple, « @SuppressWarnings(value={"deprecation", "unchecked"}) » signifie rester silencieux au sujet des « avertissements de dépréciation » et des « avertissements de conversion non vérifiée » dans le contenu annoté. Exemple :


SuppressWarningTest.java
public class SuppressWarningTest {
//@SuppressWarnings(value={"deprecation"})
public static void doSomething(){
Date date = new Date(113, 8, 26);
System.out.println(date);
}
public static void main(String[] args) {
doSomething();
}
}
Explication :
(01) Dans la figure de gauche, @SuppressWarnings(value={"deprecation"}) n'est pas utilisé, et Date est une classe que Java ne recommande plus d'utiliser. Par conséquent, l'appel de l'API de Date produira un avertissement. Dans la figure de droite, @SuppressWarnings(value={"deprecation"}) est utilisé. Par conséquent, le compilateur reste silencieux au sujet de l'"avertissement généré par l'appel de l'API de Date".
Supplément : Tableau des mots-clés couramment utilisés pour SuppressWarnings
deprecation -- 使用了不赞成使用的类或方法时的警告 unchecked -- 执行了未检查的转换时的警告,例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型。 fallthrough -- 当 Switch 程序块直接通往下一种情况而没有 Break 时的警告。 path -- 在类路径、源文件路径等中有不存在的路径时的警告。 serial -- 当在可序列化的类上缺少 serialVersionUID 定义时的警告。 finally -- 任何 finally 子句不能正常完成时的警告。 all -- 关于以上所有情况的警告。
4. Le rôle de l'annotation
L'annotation est une classe auxiliaire largement utilisée dans les frameworks d'outils tels que Junit, Struts et Spring.
Les fonctions d'annotation que nous utilisons souvent en programmation comprennent :
1) Vérification à la compilation
L'annotation a la "fonction de permettre au compilateur d'effectuer des vérifications à la compilation".
Par exemple, @SuppressWarnings, @Deprecated et @Override ont tous une fonction de vérification à la compilation.
(01) @SuppressWarnings et @Deprecated ont déjà fait l'objet d'une description détaillée dans la "Partie 3". Aucun autre exemple ne sera donné ici.
(02) Si une méthode est marquée avec @Override, cela signifie que la méthode redéfinit une méthode portant le même nom dans la classe parente. Si une méthode est marquée avec @Override, mais que la classe parente n'a pas de méthode portant le même nom qui est "marquée avec @Override", le compilateur signalera une erreur. Exemple :

OverrideTest.java
/**
* toString() est défini dans java.lang.Object;
* Par conséquent, l'utilisation de @Override ici est correcte.
*/
@Override
public String toString(){
return "Override toString";
}
/**
* getString() n'est défini dans aucune classe parente de OverrideTest;
* Cependant, il est annoté avec @Override ici, donc une erreur de compilation se produira !
*/
@Override
public String getString(){
return "get toString";
}
public static void main(String[] args) {
}
}
Ce qui précède est une capture d'écran du programme dans eclipse. On peut y voir que la fonction "getString()" signalera une erreur. Cela est dû au fait que "getString() est annoté avec @Override, mais getString1() n'est défini dans aucune classe parente de OverrideTest".
Mettre en commentaire "@Override au-dessus de getString()" résoudra l'erreur.
2) Utilisation des annotations dans la réflexion
Dans les fonctions de réflexion telles que Class, Method et Field, il existe de nombreuses interfaces liées à Annotation.
Cela signifie aussi que nous pouvons analyser et utiliser Annotation dans la réflexion.
AnnotationTest.java
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
import java.lang.reflect.Method;
/**
* Exemple d'utilisation d'Annotation dans les fonctions de réflexion
*/
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
String[] value() default "unknown";
}
/**
* Classe Person. Elle utilisera l'annotation MyAnnotation.
*/
class Person {
/**
* La méthode empty() est marquée à la fois par "@Deprecated" et "@MyAnnotation(value={"a","b"})"
* (01) @Deprecated signifie que la méthode empty() n'est plus recommandée pour l'utilisation
* (02) @MyAnnotation signifie que la valeur de MyAnnotation correspondant à la méthode empty() est la valeur par défaut "unknown"
*/
@MyAnnotation
@Deprecated
public void empty(){
System.out.println("\nempty");
}
/**
* sombody() est marqué par @MyAnnotation(value={"girl","boy"}),
* @MyAnnotation(value={"girl","boy"}) signifie que la valeur de MyAnnotation est {"girl","boy"}
*/
@MyAnnotation(value={"girl","boy"})
public void somebody(String name, int age){
System.out.println("\nsomebody: "+name+", "+age);
}
}
public class AnnotationTest {
public static void main(String[] args) throws Exception {
// Créer un nouveau Person
Person person = new Person();
// Obtenir l'instance de Class de Person
Class<Person> c = Person.class;
// Obtenir l'instance Method de la méthode somebody()
Method mSomebody = c.getMethod("somebody", new Class[]{String.class, int.classe});
// Exécuter la méthode
mSomebody.invoke(person, new Object[]{"lily", 18});
iteratorAnnotations(mSomebody);
// Obtenir l'instance Method de la méthode somebody()
Method mEmpty = c.getMethod("empty", new Classe[]{});
// Exécuter la méthode
mEmpty.invoke(person, new Object[]{});
iteratorAnnotations(mEmpty);
}
public static void iteratorAnnotations(Method method) {
// Déterminer si la méthode somebody() contient l'annotation MyAnnotation
if(method.isAnnotationPresent(MyAnnotation.class)){
// Obtenir l'instance d'annotation MyAnnotation de la méthode
MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
// Obtenir la valeur de myAnnotation et l'afficher
String[] values = myAnnotation.value();
for (String str:values)
System.out.printf(str+", ");
System.out.println();
}
// Obtenir toutes les annotations sur la méthode et les afficher
Annotation[] annotations = method.getAnnotations();
for(Annotation annotation : annotations){
System.out.println(annotation);
}
}
}
Sortie :
somebody: lily, 18 girl, boy, @com.skywang.annotation.MyAnnotation(value=[girl, boy]) empty unknown, @com.skywang.annotation.MyAnnotation(value=[unknown]) @java.lang.Deprecated()
3) Génération de la documentation d'aide basée sur les annotations
En ajoutant la balise @Documented à une annotation Annotation, la balise Annotation peut apparaître dans javadoc.
4) Utile pour la visualisation du code
Grâce à @Override, @Deprecated, etc., nous pouvons facilement comprendre la structure générale d'un programme.
De plus, nous pouvons également implémenter certaines fonctionnalités via des Annotations personnalisées.
Adresse d'origine : https://www.cnblogs.com/skywang12345/p/3344137.html