Utilisation de l'annotation Annotation Compréhension approfondie des annotations dans Java Annotations méta-annotations personnalisées

annotation

1. Concept

(1) Annotation: utilisée pour expliquer le programme, pour que l'ordinateur puisse voir, les nouvelles fonctionnalités après l'
utilisation du JDK1.5 :@注解名称

(2) Annotation: Décrivez le programme en texte pour les codeurs

2. Fonction

(1) Ecrire un document
Générez un document doc à partir des annotations identifiées dans le code:

① Créez une classe

/**
 * 注解javadoc演示
 * @author 周杰伦  表示此类(文档)作者
 * @version 1.0  表示此类(文档)的版本
 * @since 1.8  表示从JDK1.8之后可以使用此类
 */
public class AnnoDemo1 {
    
    
    /**
     * 计算两数的和
     * @param a 整数
     * @param b 整数
     * @return 两数的和
     */
    public int add(int a, int b ){
    
    
        return a + b;
    }
}

② Utilisez les instructions javadoc pour ce fichier java

③ Ouvrez le fichier doc

(2) Analyse de code: utilisez la réflexion pour analyser le code à travers les annotations dans le code

(3) Vérification de la compilation: réaliser la vérification de la compilation par annotation, telle que@Override

3. Annotations personnalisées

(1) Format

public @interface 注解名称 {
    
    
// 属性列表；
}

(2) Essence

L'annotation est essentiellement une interface qui hérite de l'interface d'annotation par défaut, comme suit:

public interface 自定义注解 extends java.lang.annotation.Annotation {
    
    }

(3) Attributs dans les annotations

Les attributs annotés sont des méthodes abstraites dans l'interface

Prétendre:

① Le type de valeur de retour de la propriété:
i. Type de données de base
ii. Type de chaîne Chaîne
iii. Énumération
iiii. Remarque
iiiii. Tableau des types ci-dessus
Remarque: les autres types tels que le type de classe et void ne sont pas autorisés

② Après avoir défini l'attribut, vous devez attribuer une valeur à l'attribut lors de son utilisation

// 自定义注解
public @interface MyAnno {
    
    
    //以下均为省略了abstract关键字的抽象方法

    Person per(); //枚举类型，其中有P1，P2

    MyAnno2 anno2(); // 注解类型，定义另一个注解MyAnno2

    String[] strs(); // 数组类型

    //使用default关键字给属性赋值，表示默认初始值，
    //则使用注解时，可以不给此属性赋值，而使用默认值
    int value() default 15; //基本数据类型
}

// 使用注解
// 数组赋值时，值使用{}包裹，如果数组中只有一个值，可以省略{}
@MyAnno(per = Person.P1, anno2 = @MyAnno2, strs={
    
    "bbb", "ccc"})
public class Worker {
    
     // 自定义类
    //成员变量、属性
}

Remarque:

1. S'il n'y a qu'un seul attribut dans l'annotation et que le nom est valeur, quel que soit le type de valeur, la valeur peut être omise lors de son affectation, et la valeur peut être directement définie, telle que@SuppressWarnings(“all”)

2. Plusieurs annotations différentes peuvent être utilisées en même temps pour la même classe ou méthode

4. Annotations Meta

Annotations utilisées pour décrire les annotations. Écrivez des méta-annotations dans la ligne supérieure des annotations personnalisées. Il existe quatre types:

(1) @Target： Décrivez la position où l'annotation peut fonctionner.
Attribut: ElementType [] value (); Parmi eux, ElementType est un type énuméré, valeur couramment utilisée:

• TYPE signifie qu'il peut agir sur la classe
• METHOD signifie qu'il peut agir sur des méthodes
• FIELD signifie qu'il peut agir sur des variables

(2) @Retention: Décrivez le stade auquel l'annotation est conservée.
Attribut: RetentionPolicy value (); où RetentionPolicy est un type énuméré et sa valeur est:

• RUNTIME signifie que l'annotation actuelle sera conservée dans le fichier de classe et lue par la machine virtuelle Java. Cette valeur est la plus couramment utilisée et peut également prendre la valeur SOURCE, CLASS

(3) @Documented: Les commentaires descriptifs peuvent être extraits dans des documents API

(4) @Inherited: Les annotations descriptives peuvent être héritées: si la classe parente utilise l'annotation décrite par cette méta-annotation, la sous-classe qui hérite de cette classe sera automatiquement décrite par cette annotation même si elle n'écrit aucune annotation

@Target({
    
    ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
//自定义注解Pro
public @interface Pro {
    
    
    String className();
    String methodName();
}

5. Obtenez la valeur d'attribut de l'annotation

// 使用上述自定义注解Pro
@Pro(className = "cn.itcast.annotation.Demo1", methodName = "show")
public class ReflectTest {
    
    
    public static void main(String[] args) throws Exception {
    
    
        // 1. 使用该类的字节码文件对象解析注解
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        // 2. 获取指定的注解对象
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        // 第二步其实就是在内存中生成了一个该注解接口的子类实现对象
        
        /*
            public class ProImpl implements Pro{
                public String className(){
                    return "cn.itcast.annotation.Demo1";
                }
                public String methodName(){
                    return "show";
                }
            }
        */
        
        // 3. 调用注解对象中定义的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className); //cn.itcast.annotation.Demo1
        System.out.println(methodName); //show
    }
}

Remarque: lorsque vous utilisez plusieurs annotations, appelez la méthode getAnnotation () du paramètre nul de l'objet Class pour obtenir tous les objets d'annotation et renvoyer Annoation []