Explication détaillée des points de connaissance Java : annotations et méta-annotations-javaDidacticiel-php.cn

Cet article vous apporte des connaissances pertinentes sur java Il présente principalement les problèmes liés aux annotations et aux méta-annotations, y compris une introduction de base aux annotations, une introduction de base à l'annotation, etc. tout le monde.

Explication détaillée des points de connaissance Java : annotations et méta-annotations

Étude recommandée : "Tutoriel vidéo Java"

1. Introduction de base aux annotations

L'annotation (annotation) est également appelée métadonnées (Metadata), qui a été introduite dans JDK1.5 et les versions ultérieures , utilisé pour modifier et interpréter les informations de données telles que les packages, les classes, les méthodes, les propriétés, les constructeurs, les variables locales, etc. 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.

Des annotations existent dans le code avec '@annotation name' Selon le nombre de paramètres d'annotation, nous pouvons diviser les annotations en trois catégories : les annotations de marque, les annotations à valeur unique et les annotations complètes. Comme les commentaires, les annotations n'affectent pas la logique du programme, mais elles peuvent être compilées ou exécutées et sont équivalentes à des informations supplémentaires intégrées dans le code.

De plus, vous pouvez choisir si les annotations dans le code n'existent qu'au niveau du code source lors de la compilation, ou si elles peuvent également apparaître dans les fichiers de classe ou au runtime (SOURCE/CLASS/RUNTIME).

En JavaSE, le but de l'utilisation des annotations est relativement simple, comme marquer les fonctions obsolètes, ignorer les avertissements, etc. Les annotations jouent un rôle plus important dans Java EE, par exemple en étant utilisées pour configurer n'importe quel aspect de l'application, remplaçant ainsi le code fastidieux et la configuration XML laissés dans l'ancienne version de Java EE.

2. Introduction de base à l'annotation

1. Trois annotations de base

@Override : Limiter une méthode, c'est remplacer la méthode de la classe parent , Cette annotation ne peut être utilisée que pour les méthodes

@Obsolète : utilisé pour représenter un certain élément de programme ( Catégorie , Méthodes, etc. ) Obsolète

@SuppressWarnings : Supprimer les avertissements du compilateur

2, exemple de code

@Override

class Son extends Father{

    @Override
    public void play(){}

}

Copier après la connexion

Remarque :

@Override représente le jeu des remplacements de méthodes de sous-classes la classe des parents Play

没有没有 Si tu ne l'écris pas ici @Remplacer Il remplacera toujours la classe parent ply

Si vous écrivez l'annotation @Override, le compilateur vérifiera si la méthode remplace réellement la classe parent Méthode, si elle est effectivement réécrite, la compilation réussira ; si elle n'est pas réécrite, l'erreur de compilation se produira.

@Override ne peut modifier que les méthodes, pas les autres classes, packages, propriétés, etc.

@Obsolète

@Deprecated
class A{
    @Deprecated
    public static int name = 1;

    @Deprecated
    public void play(){ }
}

Copier après la connexion

Remarque :

peut modifier des méthodes, des classes, des champs, des packages, des paramètres, etc.

Son rôle est d'assurer la compatibilité et transition entre l'ancienne et la nouvelle version

SuppressWarnings

@SuppressWarnings ("all")
public class word{ }

Copier après la connexion

关键字	解释
all	抑制所有警告
boxing	抑制与封装/拆装作业相关的警告
cast	抑制与强制转型作业相关的警告
dep-ann	抑制与淘汰注释相关的警告
deprecation	抑制与淘汰的相关警告
fallthrough	抑制与 switch 陈述式中遗漏 break 相关的警告
finally	抑制与未传回 finally 区块相关的警告
hiding	抑制与隐藏变数的区域变数相关的警告
incomplete-switch	抑制与 switch 陈述式(enum case)中遗漏项目相关的警告
javadoc	抑制与 javadoc 相关的警告
nls	抑制与非 nls 字串文字相关的警告
null	抑制与空值分析相关的警告
rawtypes	抑制与使用 raw 类型相关的警告
resource	抑制与使用 Closeable 类型的资源相关的警告
restriction	抑制与使用不建议或禁止参照相关的警告
serial	抑制与可序列化的类别遗漏 serialVersionUID 栏位相关的警告
static-access	抑制与静态存取不正确相关的警告
static-method	Supprimer les avertissements liés aux méthodes qui peuvent être déclarées statique
super	Supprimer les avertissements liés aux méthodes de substitution sans super appels
synthétique-access	Supprimer les avertissements liés à l'accès non optimisé aux classes internes
sync-override	Supprimer la méthode de synchronisation de remplacement Avertissements concernant la synchronisation manquante
non coché	Supprimer les avertissements liés aux travaux non cochés
accès au champ non qualifié	Supprimer avec les avertissements liés au champ non qualifié accès
unused	Supprimer les avertissements liés au code inutilisé et au code désactivé

注意：

         关于 SuppressWarnings 作用范围是和你放置的位置相关。比如@SuppressWarnings 放置在 main 方法，那么抑制警告的范围就是 main

         通过 @SuppressWarnings 的源码可知，其注解目标为类、字段、函数、函数入参、构造函数和函数的局部变量。

三、@SuppressWarnings的指定警告类型

关键字 解释

all 抑制所有警告

boxing 抑制与封装/拆装作业相关的警告

cast 抑制与强制转型作业相关的警告

dep-ann 抑制与淘汰注释相关的警告

deprecation 抑制与淘汰的相关警告

fallthrough 抑制与 switch 陈述式中遗漏 break 相关的警告

finally 抑制与未传回 finally 区块相关的警告

hiding 抑制与隐藏变数的区域变数相关的警告

incomplete-switch 抑制与 switch 陈述式(enum case)中遗漏项目相关的警告

javadoc 抑制与 javadoc 相关的警告

nls 抑制与非 nls 字串文字相关的警告

null 抑制与空值分析相关的警告

rawtypes 抑制与使用 raw 类型相关的警告

resource 抑制与使用 Closeable 类型的资源相关的警告

restriction 抑制与使用不建议或禁止参照相关的警告

serial 抑制与可序列化的类别遗漏 serialVersionUID 栏位相关的警告

static-access 抑制与静态存取不正确相关的警告

static-method Supprimer les avertissements liés aux méthodes qui peuvent être déclarées statique

super Supprimer les avertissements liés aux méthodes de substitution sans super appels

synthétique-access Supprimer les avertissements liés à l'accès non optimisé aux classes internes

sync-override Supprimer la méthode de synchronisation de remplacement Avertissements concernant la synchronisation manquante

non coché Supprimer les avertissements liés aux travaux non cochés

accès au champ non qualifié Supprimer avec les avertissements liés au champ non qualifié accès

unused Supprimer les avertissements liés au code inutilisé et au code désactivé

4. Méta-annotation

1. Introduction de base

▶ Qu'est-ce que la méta-annotation :

La méta-annotation est une annotation qui explique l'annotation L'objet de son annotation est l'annotation que nous avons introduite. plus tôt, tels que : @Override, @Deprecated, @SuppressWarnings

▶ Quatre méta-annotations :

Rétention : La portée de l'annotation, trois types : SOURCE, CLASSE, EXÉCUTION

                                                                                                                                                                                                                                                                                            Hérité : La sous-classe héritera des annotations de la classe parent.

▶ Notes sur l'annotation : #

et C 在 La note existera dans le fichier de bytecode de classe que vous pouvez obtenir par réflexion au moment de l'exécution

doit d'abord indiquer clairement que la longueur du cycle de vie source &. lt; classe & lt;                  ① : Généralement, si vous avez besoin d'obtenir dynamiquement des informations d'annotation au runtime
, vous ne pouvez utiliser que les annotations RUNTIME
              ② : Si vous souhaitez effectuer certaines opérations de prétraitement au compile time, comme générer des opérations auxiliaires. coder (comme B utterKnife ), utilisez simplement l'annotation CLASS ;
③ : Si vous effectuez simplement quelques opérations de
vérification telles que @Override et @SuppressWarnings, vous pouvez utiliser l'annotation SOURCE.

2. Annotation de rétention

Explication :

ne peut être utilisée que pour modifier une définition d'Annotation,
La

Annotation
peut retenir plus Pour un Pendant longtemps, @Rentention contient une variable membre de type
RetentionPolicy. Lorsque vous utilisez
@Rentention , vous devez spécifier une valeur pour cette variable membre
value
(il y a trois valeurs). Trois valeurs : RetentionPolicy.SOURCE: Une fois le compilateur utilisé, supprimez simplement les commentaires pour cette stratégie.

RetentionPolicy.CLASS : Le compilateur enregistrera l'annotation en classe Dans le dossier . Lors de la course Java Durée de la procédure , JVM Les annotations ne seront pas conservées. Il s'agit de la valeur par défaut.

RetentionPolicy.RUNTIME : Le compilateur enregistrera l'annotation en classe Dans le dossier . Lors de la course Java Procédure , JVM Les annotations seront conservées . Le programme peut obtenir cette annotation par réflexion.
3. L'annotation cible

explication :

est utilisée pour modifier la définition de l'annotation, en spécifiant les éléments du programme que l'annotation modifiée peut être utilisée pour modifier. @Target contient également une variable membre nommée valeur.
4,
Annotation documentée
Explication :
@Documenté : Utilisé pour préciser que la classe Annotation modifiée par cette méta-annotation sera extraite dans un document par l'outil javadoc, c'est-à-dire le document généré, vous pouvez voir l'annotation.

Remarque :

Les annotations définies comme @Documenté doivent définir la valeur de rétention sur RUNTIME.

5. Annotation héritée
Explication :

L'annotation modifiée par @Inherited aura l'héritage, si une classe Annotations modifiées par @ Les héritages sont utilisés, puis ses les sous-classes auront automatiquement cette annotationApprentissage recommandé : "
Tutoriel vidéo 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!