Comment implémenter les annotations couramment utilisées en Java ?

「Java」Savez-vous comment sont implémentées les annotations Java que nous utilisons souvent ? Les annotations sont équivalentes aux balises. La différence entre elles et les annotations est que le contenu des annotations peut être utilisé. Ensuite, découvrons les annotations Java.

Pour utiliser les annotations, nous pouvons les diviser en trois parties, à savoir : l'annotation elle-même, la classe d'utilisation des annotations et la classe de traitement des annotations, comme indiqué ci-dessous : Description de l'image

La structure de l'annotation

Ensuite, voyons comment fonctionne le code

Étape 1 : Créer de nouvelles annotations
Créez deux nouvelles annotations, à savoir PlayerName et PlayerInfor

PlayerName :

importer java.lang.annotation.Documented;

importer java.lang.annotation.ElementType;

importer java.lang.annotation.Retention;

importer java.lang.annotation .RetentionPolicy;

importer java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

@Documented

public @interface PlayerName {

String value() par défaut "";

}

PlayerInfor :

importer java .lang.annotation.Documented;

importer java.lang.annotation.ElementType;

importer java.lang.annotation.Retention;

importer java .lang.annotation. >

@ Documenté

public @interface PlayerInfor {

public enum Color{Bleu, Rouge, Blanc};

Color color() par défaut Color.Blue;

int number() par défaut 7;

int age();

String club() par défaut "Manchester United";

}

Deuxième étape : définissez la classe d'entité et utilisez l'annotation nouvellement créée

pour créer une nouvelle classe FootballPlayer

FootballPlayer :

classe publique FootballPlayer {

// Lier l'annotation PlayerName Dans l'attribut name de la classe d'entité

@PlayerName("Rooney")

public String name;

//Lier l'annotation PlayerInfor à playInfo attribut de la classe d'entité

@PlayerInfor(color=Color.Red,number=10,age=30)

public String playInfo;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getPlayInfo() {

return playInfo;

}

public void setPlayInfo(String playInfo) {

this.playInfo = playInfo;

}

}

Étape 3 : Définir la classe de traitement des annotations pour traiter les annotations des classes d'entités

Créer une nouvelle classe d'outils AnnoUtil

AnnoUtil :

import java.lang.reflect.Field;

classe publique AnnoUtil {

public static void getPlayerInfo(Class clazz){

/

Récupérer tous les attributs de la classe d'entité

/

Field[] field = clazz.getFields();

//Boucle pour extraire les annotations dans le Attributs de classe d'entité

for(Field field:fields){

//Match annotation

if(field.isAnnotationPresent(PlayerName.class)){

//Obtenir l'annotation

PlayerName name = field.getAnnotation(PlayerName.class);

//Utiliser les annotations

System.out.println("Nom de l'athlète : " +name.value());

}else if(field.isAnnotationPresent(PlayerInfor.class)){

//Obtenir l'annotation

PlayerInfor infor = field.getAnnotation (PlayerInfor.class);

//Utiliser les annotations

System.out.println("Affiliation à l'équipe : "+infor.club()+", représentant la couleur : "

+infor.color() +", numéro : "+infor.number()+", âge : "+infor.age());

}

}

}

}

Étape 4 : Appeler la méthode de traitement de la classe de traitement

public static void main(String[] args) {

AnnoUtil .getPlayerInfo(FootballPlayer.class);

}

Les résultats de sortie sont les suivants :

Nom de l'athlète : Rooney

Équipe : Manchester United, représentant couleur : Rouge, nombre : 10, âge :30

D'après le programme ci-dessus, on peut comprendre que : la relation entre les classes d'entités et les annotations est comme les articles et les notes, et la classe de traitement des annotations est comme les personnes ; les gens lisent des articles avec des notes, les analysent et les traitent, et génèrent le résultat que vous souhaitez exprimer.

Pièce jointe :

Java fournit quatre méta-annotations, qui sont spécifiquement responsables de l'annotation d'autres annotations, comme suit :

@Méta-annotation de rétention, indiquant à quel niveau les informations d'annotation ont besoin à sauvegarder (cycle de vie). Les paramètres RetentionPoicy facultatifs incluent :

RetentionPolicy.SOURCE : reste dans le fichier source Java, le compilateur sera supprimé

RetentionPolicy.CLASS : reste dans le fichier de classe, mais sera supprimé par la VM (par défaut)

RetentionPolicy.RUNTIME : bytecode en mémoire, la VM conservera également les annotations au moment de l'exécution, afin que les informations d'annotation puissent être lues via le mécanisme de réflexion

Méta-annotation @Target, valeur par défaut Pour tout élément, indique où l'annotation est utilisée. Les paramètres ElementType disponibles incluent

ElementType.CONSTRUCTOR : déclaration du constructeur

ElementType.FIELD : variables membres, objets, propriétés (y compris les instances d'énumération)

ElementType.LOCAL_VARIABLE : déclaration de variable locale

ElementType.METHOD : Déclaration de méthode

ElementType.PACKAGE : Déclaration de package

ElementType.PARAMETER : Déclaration de paramètre

ElementType.TYPE : Classe, Interface ( y compris le type d'annotation) ou une déclaration enum

@Documented inclut des annotations dans JavaDoc

@Inheried permet aux sous-classes d'hériter des annotations dans les classes parentes [1] : /img/bVbekSZ

Je viens de compiler un ensemble des derniers didacticiels d'introduction et avancés de base 0 en 2018. Je les partage de manière désintéressée. Vous pouvez les obtenir en ajoutant le numéro d'apprentissage Java : 678-241-563. Sont inclus : les outils de développement et les packages d'installation. , ainsi que l'image des itinéraires d'apprentissage du système.

Articles associés :

Résumé des annotations les plus couramment utilisées en Java

Tutoriels d'annotations Java et annotations personnalisées

Vidéos associées :

Analyse complète des annotations 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!