Compréhension approfondie de Java : concepts de base de l'annotation

Qu'est-ce que l'annotation (Annotation) :

L'annotation (annotation) est que Java fournit un moyen et une méthode permettant aux éléments d'un métaprogramme d'associer toute information et toute métadonnée (métadonnées). L'annotation (annotation) est une interface. Le programme peut obtenir l'objet Annotation de l'élément de programme spécifié par réflexion, puis obtenir les métadonnées dans l'annotation via l'objet Annotation.

L'annotation est introduite dans JDK5.0 et les versions ultérieures. Il peut être utilisé pour créer de la documentation, suivre les dépendances dans votre code et même effectuer des vérifications de base au moment de la compilation. D'une certaine manière, les annotations sont utilisées comme des modificateurs et sont appliquées à la déclaration des packages, des types, des constructeurs, des méthodes, des variables membres, des paramètres et des variables locales. Ces informations sont stockées dans la paire de structures "nom=valeur" de l'annotation.

Les membres d'Annotation sont déclarés comme méthodes sans paramètre dans le type Annotation. Son nom de méthode et sa valeur de retour définissent le nom et le type du membre. Il existe ici une syntaxe par défaut spécifique : il est permis de déclarer la valeur par défaut de n'importe quel membre d'Annotation : une Annotation peut utiliser une paire nom=valeur comme valeur d'un membre d'Annotation qui ne définit pas de valeur par défaut, bien sûr, un nom. La paire =value peut également être utilisée pour remplacer la valeur par défaut des autres membres. Ceci est quelque peu similaire aux caractéristiques d'héritage des classes. Le constructeur de la classe parent peut être utilisé comme constructeur par défaut de la sous-classe, mais il peut également être remplacé par la sous-classe.

L'annotation peut être utilisée pour associer n'importe quelle information à un certain élément de programme (classe, méthode, variable membre, etc.). Il convient de noter qu'il existe ici une règle de base : l'annotation ne peut pas affecter l'exécution du code du programme. Peu importe si une annotation est ajoutée ou supprimée, le code sera exécuté de manière cohérente. De plus, bien que certaines annotations soient accessibles au moment de l'exécution via les méthodes de l'API de réflexion de Java, l'interpréteur du langage Java ignore ces annotations pendant son travail. C'est précisément parce que la machine virtuelle Java ignore l'annotation que le type d'annotation « ne fonctionne pas » dans le code ; les informations du type d'annotation ne sont accessibles et traitées que via certains outils de support. Cet article couvrira les types d'annotations et de méta-annotations standard. L'outil qui accompagne ces types d'annotations est le compilateur Java (qui les gère bien sûr d'une manière spéciale).

---

Qu'est-ce que les métadonnées (métadonnées) :

Les métadonnées sont traduites du mot métadonnées, qui signifie « données sur les données ».
Les métadonnées ont de nombreuses fonctions. Par exemple, vous avez peut-être utilisé des commentaires Javadoc pour générer automatiquement des documents. Il s'agit d'un type de fonction de métadonnées. En général, les métadonnées peuvent être utilisées pour créer de la documentation, suivre les dépendances du code, effectuer des vérifications de format au moment de la compilation et remplacer les fichiers de configuration existants. Si l'on veut classer le rôle des métadonnées, il n'existe actuellement pas de définition claire, mais on peut grossièrement la diviser en trois catégories en fonction de son rôle :
　1. Rédaction de documents : Générés grâce aux métadonnées identifiées dans le code Document
2. Analyse du code : Analysez le code à travers les métadonnées identifiées dans le code
3. Vérification de la compilation : Les métadonnées identifiées dans le code permettent au compilateur d'implémenter des vérifications de compilation de base
En Java Les métadonnées existent dans le code Java sous la forme de balises. L'existence de balises de métadonnées n'affecte pas la compilation et l'exécution du code du programme. Elles sont uniquement utilisées pour générer d'autres fichiers ou pour connaître les informations de description du code en cours d'exécution.
En résumé :
Premièrement, les métadonnées existent dans le code Java sous forme de balises.
Deuxièmement, les informations décrites par les métadonnées sont de type sécurisé, c'est-à-dire que les champs des métadonnées ont des types clairs.
Troisièmement, les métadonnées nécessitent un traitement supplémentaire par des outils autres que le compilateur pour générer d'autres composants du programme.
Quatrièmement, les métadonnées ne peuvent exister qu'au niveau du code source Java, ou elles peuvent exister dans le fichier Class compilé.

---

Annotation et type d'annotation :

Annotation :

L'annotation utilise la nouvelle syntaxe apportée par java5.0. Son comportement est très similaire à un tel modificateur public et final. . Chaque annotation a un nom et un nombre de membres >= 0. Chaque membre d'une annotation a un nom et une valeur appelés une paire nom=valeur (tout comme un javabean), et nom=valeur charge les informations d'annotation.

Type d'annotation :

Le type d'annotation définit le nom, le type et la valeur par défaut du membre de l'annotation. Un type Annotation peut être considéré comme une interface Java spéciale. Ses variables membres sont restreintes et une nouvelle syntaxe est requise lors de la déclaration d'un type Annotation. Lorsque nous accédons à Annotation via l'API de réflexion Java, la valeur de retour sera un objet qui implémente l'interface de type d'annotation. En accédant à cet objet, nous pouvons facilement accéder à ses membres Annotation. Les chapitres suivants mentionneront les trois types d'annotations standard inclus dans le package java.lang de java5.0.

---

Classification des annotations :

Selon le nombre de paramètres d'annotation, nous pouvons diviser les annotations en trois catégories :
1. Annotation de marque : un type d'annotation sans définition de membre est appelé une annotation de marque. Ce type d'annotation utilise uniquement sa propre présence ou absence pour nous fournir des informations. Par exemple, l'annotation système suivante @Override;
2. Annotation à valeur unique
3. Annotation complète

Selon l'utilisation et le but de l'annotation, nous pouvons diviser l'annotation en trois catégories :
1. Annotations système intégrées au JDK
2. Méta-annotations
3. Annotations personnalisées

---

Annotations standard intégrées au système :

La syntaxe d'annotation est relativement simple , à l'exception de l'utilisation du symbole @ De plus, il est fondamentalement cohérent avec la syntaxe inhérente à Java. Il existe trois annotations standard intégrées à JavaSE, qui sont définies dans java.lang :
@Override : utilisé pour modifier cela. méthode pour couvrir la méthode de la classe parent ;
@Deprecated : utilisé pour modifier les méthodes obsolètes ;
@SuppressWarnings : utilisé pour avertir le compilateur Java de supprimer les avertissements de compilation spécifiques.

Examinons tour à tour les fonctions et les scénarios d'utilisation des trois annotations standard intégrées.

---

@Override, limité au remplacement des méthodes de classe parent :

@Override est un type d'annotation de marque, qui est utilisé comme méthode d'annotation. Cela montre que la méthode annotée surcharge la méthode de la classe parent et joue le rôle d'assertion. Si nous utilisons ce type d'annotation dans une méthode qui ne remplace pas la méthode de la classe parent, le compilateur Java vous avertira avec une erreur de compilation. Cette annotation entre souvent en jeu lorsque nous essayons de remplacer une méthode de classe parent mais que nous écrivons un mauvais nom de méthode. L'utilisation est extrêmement simple : lors de l'utilisation de cette annotation, il suffit d'ajouter @Override devant la méthode modifiée. Le code suivant est un exemple d'utilisation de @Override pour modifier une tentative de remplacement de la méthode displayName() d'une classe parent, mais avec une faute de frappe :

public class Fruit {

    public void displayName(){
        System.out.println("水果的名字是：*****");
    }
}

class Orange extends Fruit {
    @Override
    public void displayName(){
        System.out.println("水果的名字是：桔子");
    }
}

class Apple extends Fruit {
    @Override
    public void displayname(){
        System.out.println("水果的名字是：苹果");
    }
}

　 Orange 类编译不会有任何问题，Apple 类在编译的时候会提示相应的错误。@Override注解只能用于方法，不能用于其他程序元素。

---

@Obsolète, la balise est obsolète :

De même, Obsolète est également une annotation de balise. Lorsqu'un type ou un membre de type est décoré avec @Deprecated, le compilateur découragera l'utilisation de cet élément de programme annoté. Et ce type de modification a un certain degré de « continuité » : si nous utilisons ce type ou ce membre obsolète dans le code par héritage ou écrasement, bien que le type ou le membre hérité ou remplacé ne soit pas déclaré @Deprecated, le compilateur doit toujours avertir toi.

Il est à noter qu'il existe une différence entre le type d'annotation @Deprecated et la balise @deprecated dans javadoc : le premier est reconnu par le compilateur java, tandis que le second est reconnu par l'outil javadoc et utilisé pour générer des documents (y compris des programmes Une description des raisons pour lesquelles le membre est obsolète et comment il doit être banni ou remplacé).

Dans Java 5.0, le compilateur Java recherche toujours les balises javadoc @deprecated comme il le faisait dans les versions précédentes et les utilise pour générer des messages d'avertissement. Mais cette situation changera dans les versions ultérieures, et nous devrions maintenant commencer à utiliser @Deprecated pour décorer les méthodes obsolètes au lieu de la balise javadoc @deprecated.

Dans le programme suivant, l'annotation @Deprecated est utilisée pour marquer la méthode comme expirée. En même temps, la balise @deprecated est utilisée dans l'annotation de la méthode pour marquer la méthode comme obsolète. suit :

 class AppleService {
    public void displayName(){
        System.out.println("水果的名字是：苹果");
    }
    
    /**
     * @deprecated 该方法已经过期，不推荐使用
     */
    @Deprecated
    public void showTaste(){
        System.out.println("水果的苹果的口感是：脆甜");
    }
    
    public void showTaste(int typeId){
        if(typeId==1){
            System.out.println("水果的苹果的口感是：酸涩");
        }
        else if(typeId==2){
            System.out.println("水果的苹果的口感是：绵甜");
        }
        else{
            System.out.println("水果的苹果的口感是：脆甜");
        }
    }
}

public class FruitRun {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Apple apple=new Apple();
        apple.displayName();    
        
        AppleService appleService=new AppleService();
        appleService.showTaste();
        appleService.showTaste(0);
        appleService.showTaste(2);
    }

}

　　AppleService类的showTaste() 方法被@Deprecated标注为过时方法，在FruitRun类中使用的时候，编译器会给出该方法已过期，不推荐使用的提示。

---

SuppressWarnnings，抑制编译器警告：

　　@SuppressWarnings 被用于有选择的关闭编译器对类、方法、成员变量、变量初始化的警告。在java5.0，sun提供的javac编译器为我们提供了-Xlint选项来使编译器对合法的程序代码提出警告，此种警告从某种程度上代表了程序错误。例如当我们使用一个generic collection类而又没有提供它的类型时，编译器将提示出"unchecked warning"的警告。通常当这种情况发生时，我们就需要查找引起警告的代码。如果它真的表示错误，我们就需要纠正它。例如如果警告信息表明我们代码中的switch语句没有覆盖所有可能的case，那么我们就应增加一个默认的case来避免这种警告。
　　有时我们无法避免这种警告，例如，我们使用必须和非generic的旧代码交互的generic collection类时，我们不能避免这个unchecked warning。此时@SuppressWarning就要派上用场了，在调用的方法前增加@SuppressWarnings修饰，告诉编译器停止对此方法的警告。
　　SuppressWarning不是一个标记注解。它有一个类型为String[]的成员，这个成员的值为被禁止的警告名。对于javac编译器来讲，被-Xlint选项有效的警告 名也同样对@SuppressWarings有效，同时编译器忽略掉无法识别的警告名。
　　annotation语法允许在annotation名后跟括号，括号中是使用逗号分割的name=value对用于为annotation的成员赋值。实例如下：

public class FruitService {
    
    @SuppressWarnings(value={ "rawtypes", "unchecked" })
    public static  List<fruit> getFruitList(){
        List<fruit> fruitList=new ArrayList();
        return fruitList;
    }
    
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static  List<fruit> getFruit(){
        List<fruit> fruitList=new ArrayList();
        return fruitList;
    }

    @SuppressWarnings("unused")
    public static void main(String[] args){
        List<string> strList=new ArrayList<string>();
    }
}</string></string></fruit></fruit></fruit></fruit>

　　在这个例子中SuppressWarnings annotation类型只定义了一个单一的成员，所以只有一个简单的value={...}作为name=value对。又由于成员值是一个数组，故使用大括号来声明数组值。注意：我们可以在下面的情况中缩写annotation：当annotation只有单一成员，并成员命名为"value="。这时可以省去"value="。比如将上面方法getFruit()的SuppressWarnings annotation就是缩写的。

 　 SuppressWarnings注解的常见参数值的简单说明：

　　　　1.deprecation：使用了不赞成使用的类或方法时的警告；
　　　　2.unchecked：执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型; 
　　　　3.fallthrough：当 Switch 程序块直接通往下一种情况而没有 Break 时的警告;
　　　　4.path：在类路径、源文件路径等中有不存在的路径时的警告; 
　　　　5.serial：当在可序列化的类上缺少 serialVersionUID 定义时的警告; 
　　　　6.finally：任何 finally 子句不能正常完成时的警告; 

　　　　7.all：关于以上所有情况的警告。

学习Java的同学注意了！！！
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群：159610322   我们一起学Java！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!