java : annotations

qu'est-ce que l'annotation

L'annotation est un nouveau type de données, qui est très similaire à l'interface et se situe au même niveau que la classe, l'interface et l'énumération.

Équivalent à une marque, commençant par @, peut déclarer le devant des classes, des propriétés, des méthodes, des paramètres, etc. Utilisé pour décrire, étiqueter et implémenter des fonctions spécifiques pour les éléments

Fonction :
1. Rédaction de documents : génération de documents en fonction des annotations
2. Analyse de code : analyse du code par réflexion via des annotations
3. Inspection de compilation : permet au compilateur d'implémenter une vérification de type de base via des annotations, telles que Override

Annotations prédéfinies JDK

dans le package java.lang

annotation effet
@Passer outre Devant la méthode, remplacez la méthode de la classe parent
@Déprécié Devant les classes, les attributs et les méthodes, cela signifie obsolète et non recommandé
@SuppressWarning Devant les classes, les attributs et les méthodes, cela signifie fermer le message d'avertissement
package cn.xxx.annotation;

import java.util.Date;

@SuppressWarnings("all")
public class AnnoDemo2 {
    
    

    @Override
    public String toString() {
    
    
        return super.toString();
    }

    @Deprecated//过期注解
    public void show1(){
    
    
        //有缺陷
    }

    public void show2(){
    
    
        //替代show1方法
    }

    public void demo(){
    
    
        show1();
        Date date = new Date();
    }
}

annotation personnalisée

Utilisation de @interface+ méta-annotations

// 元注解
public @interface 注解名 {
    
    
	// 抽象方法或者叫属性列表
}

Méta-annotations : annotations taguées sur les annotations

méta-annotation effet
@Cible Définissez la portée des annotations, c'est-à-dire les éléments qui peuvent être marqués, tels que les classes, les méthodes, etc. Lorsqu'il est omis, il peut être avant n'importe quel élément
@Rétention Définir le cycle de vie des annotations, SOURCE, CLASS, RUNTIME, conserver en compilation, conserver dans la classe, utiliser généralement RUNTIME
@Documenté S'il faut inclure des annotations lors de la génération de la documentation à l'aide de javadoc
@Hérité Autoriser les sous-classes à hériter des annotations de la classe parent

Les annotations sont finalement compilées pour :

public interface MyAnno extends java.lang.annotation.Annotation {
    
    }

Ainsi, l'essence de l'annotation est une interface, qui hérite de l'interface d'annotation par défaut

package cn.xxx.annotation;

import java.lang.annotation.*;

@Target({
    
    ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {
    
    
}

Utiliser des annotations

grammaire:

@注解名(属性名=属性值,属性名=属性值)
  • Lorsque vous utilisez des annotations, vous devez spécifier la valeur de retour de la méthode abstraite dans l'annotation, également connue sous le nom de spécification de la valeur d'attribut pour l'annotation.
  • Le nom de l'attribut est le nom de la méthode abstraite dans l'annotation
package cn.xxx.annotation;

public @interface MyAnno {
    
    

     int value();
     Person per();
     MyAnno2 anno2();
     String[] strs();
     /*String name() default "张三";*/
     /*String show2();

     Person per();
     MyAnno2 anno2();

     String[] strs();*/
}
package cn.xxx.annotation;

@MyAnno(value=12,per = Person.P3,anno2 = @MyAnno2,strs={
    
    "bbb","aaa"})
@MyAnno3
public class Worker {
    
    
    @MyAnno3
    public String name = "aaa";
    @MyAnno3
    public void show () {
    
    
    }
}

analyse des annotations

Pour les annotations dont le cycle de vie est RUNTIME. L'analyse des annotations consiste à obtenir les valeurs d'attribut définies dans les annotations. Il y a trois étapes :

  1. Récupère l'objet de l'emplacement (Classe, Méthode, Champ) défini par l'annotation
  2. Obtenir l'annotation spécifiée
    • getAnnotation(Classe)
    //其实就是在内存中生成了一个该注解接口的子类实现对象
    public class ProImpl implements Pro{
          
          
        public String className(){
          
          
            return "cn.itcast.annotation.Demo1";
        }
        public String methodName(){
          
          
            return "show";
        }
    }
    
  3. Appelez la méthode abstraite dans l'annotation pour obtenir la valeur d'attribut configurée.

Exemple:

// 1、获取类上的注解
Class cls = Student.class;
// 2、获取该类Student上的所有注解,不一定获取类上的注解,也可以获取方法上的注解,这时候就是 `method.getAnnotation()`
Annotation[] annotation = cls.getAnnotations();
// 仅获取该类上的Pro注解
Pro annotation = cls.getAnnotation(Pro.class);
// 3、获取注解上的属性方法
String className = annotation.className() // cn.xxx.annotation.Demo1
String className = annotation.methodName() // show
...

Résumer

Une annotation est quelque chose de similaire à une étiquette. Par exemple, si vous mettez une annotation Check sur une fonction, cela signifie que la fonction peut être vérifiée, alors le programme de vérification correspondant peut exécuter le programme correspondant en reconnaissant l'annotation Check. S'il y a aucun programme de vérification, puis l'annotation elle-même Cela n'a aucun sens, tout comme un commentaire.

1. La plupart du temps, nous n'utilisons que des annotations, pas des annotations personnalisées
2. À qui s'adressent principalement les annotations ? 1. Compilateur 2. Programme d'analyse
3. L'annotation ne fait pas partie du programme, mais quelque chose comme une étiquette

Je suppose que tu aimes

Origine blog.csdn.net/weixin_43972437/article/details/132237180
conseillé
Classement