Aperçu
Java a introduit l'annotation dans la version 1.5, également connue sous le nom d'annotation Java. L'annotation est une sorte de métadonnées de syntaxe qui peuvent être utilisées directement dans le code source, et les classes / méthodes / variables / paramètres / noms de packages, etc. peuvent être annotés. Contrairement aux balises Javadoc, le compilateur peut conserver le code d'annotation lors de la génération du fichier de classe. Dans le même temps, afin d'utiliser des annotations pendant le processus d'exécution, la machine virtuelle Java conserve l'annotation, de sorte que les informations pertinentes sur l'annotation peuvent être obtenues par réflexion.
Annotation intégrée
En fait, nous rencontrons souvent des annotations, telles que @Override, @DepreCated, etc. Ce sont toutes des annotations intégrées dans JDK. Jetons d'abord un coup d'œil sur les principales annotations intégrées de Java.
• Annotations qui agissent sur le code Java
◦ @ Override vérifie si une méthode est une méthode de réécriture. Si cette méthode n'est pas trouvée dans la classe parent ou l'interface implémentée, une erreur de compilation se produira.
◦ @ marques obsolètes qu'une méthode ou une classe est jetée. Si la classe ou la méthode est utilisée, le processus de compilation vous alertera.
◦ @ SupressWarnings informez le compilateur pour ignorer les avertissements sur les paramètres annotés
◦ @ Safevarargs ignore les avertissements concernant les méthodes d'appel ou les constructeurs contenant des paramètres génériques, 1.7 a ajouté des annotations
◦ @ FunctionalInterface indique qu'une interface déclarée sera utilisée comme interface fonctionnelle. 1.8 a ajouté l'annotation
• Les annotations réalisées sur d'autres annotations sont appelées méta-annotations (méta-annotation)
◦ @ Rétention Spécifie lorsque l'annotation annotée est utilisée (c'est-à-dire lorsque l'annotation sera conservée)
■ Rétention dans le code source uniquement et rejeté pendant la compilation (RetenderPolicy.runtime)
■ Les annotations sont enregistrées dans le fichier de classe pendant la compilation et sont ignorées lorsque le fichier de classe est chargé (RetentionPolicy.class)
■ Les annotations sont lues lorsque le fichier de classe est chargé, c'est-à-dire que des annotations sont disponibles pendant le fonctionnement. Les annotations peuvent être obtenues par réflexion (rétentionpolicy.runtime)
◦ @ documenté indique que lors de la génération de Javadoc, les annotations annotées seront écrites dans le document Javadoc.
◦ @ Target Spécifie la portée de l'annotation annotée ■ elementType.Type: Utilisé pour décrire une classe, une interface (y compris le type d'annotation) ou une déclaration en énum ■ ElementType.field: Utilisé pour décrire le domaine ■ ElementType.Method: Utilisé pour décrire la méthode ■ ElementType.Paramètre: utilisée pour décrire les paramètres ■ ElementType. Constructeur ■ elementType.Local_variable: Utilisé pour décrire la variable locale ■ elementType.annotation_type: Utilisé pour décrire l'annotation ■ elementType.package: Utilisé pour décrire le package
◦ @ hérité indique que l'annotation est héritée, c'est-à-dire si un type d'annotation modifié par @inherited est utilisé pour une classe, l'annotation agira également sur la sous-classe de la classe modifiée.
◦ @ répétable indique que l'annotation annotée peut être appliquée au même objet plusieurs fois. 1.9 a ajouté l'annotation
Annotations personnalisées
J'ai mentionné tellement d'annotations ci-dessus, et tout le monde se concentre sur les méta-annotations. Lorsque nous personnalisons les annotations, nous utilisons généralement des méta-annotations pour nous aider. Le format d'annotation personnalisé est public @Interface Annotation Name {Definition Body}. Lorsque vous utilisez une annotation personnalisée @interface, l'interface java.lang.annotation.annotation est automatiquement héritée. Lors de la personnalisation des annotations, d'autres annotations ou interfaces ne peuvent pas être héritées. La méthode déclarée en annotation est en fait un paramètre de commentaire. Le nom de la méthode est le nom du paramètre, et le type de valeur de retour est le type du paramètre. La valeur par défaut du paramètre peut être déclarée par défaut.
Les annotations personnalisées sont simples, utilisez @Interface pour définir une annotation, comme suit.
@Retention (RetentionPolicy.Runtime) @target (elementType.Type) @DocumedPublic @Interface Classinfo {String Author () Default "Wang"; String Date (); Commentaires de chaîne ();} Une annotation personnalisée appelée classinfo. Selon @retention, vous pouvez savoir que cette annotation existera toujours, c'est-à-dire que cette annotation est toujours valable lorsque le programme est en cours d'exécution; @Target (elementType.Type) signifie que l'annotation ClassInfo agit sur la classe, l'interface ou l'énumération; @Documenté
Instructions ClassInfo Les informations peuvent être écrites dans des documents Javadoc.
Jetons un coup d'œil à certains paramètres d'annotation dans les annotations personnalisées. Il y a trois paramètres d'annotation. Les paramètres d'annotation peuvent être définis par défaut, tels que le paramètre d'annotation de l'auteur, la valeur par défaut est Wang et les deux autres paramètres n'ont aucune valeur par défaut.
Regardons une autre annotation personnalisée.
@Retention (retentionPolicy.runtime) @target (elementType.Method) public @Interface Methodinfo {String Description () Default "No Description"; Date de chaîne ();}Cette méthode d'annotation personnalisée agit sur la méthode, et cette annotation existera également lorsque le programme est en cours d'exécution; Il y a deux paramètres d'annotation.
Pour annoter la définition des paramètres (définition de la méthode), vous ne pouvez utiliser que deux modificateurs de droits d'accès publics ou par défaut. Les types de paramètres prennent en charge les types suivants.
• Huit types de données de base (octet, int, court, long, flotteur, double, char, booléen)
• Type de chaîne
• Type de classe
• Type d'énumération
• Type d'annotation
• des tableaux de tous types ci-dessus
Utilisation des annotations
En plus des deux annotations ci-dessus, une annotation avec la portée du champ a été ajoutée.
@Retention (RetentionPolicy.Runtime) @target (elementType.field) public @Interface FieldInfo {String Type (); Nom de chaîne ();}Si les valeurs par défaut ne sont pas déclarées dans les annotations personnalisées, ces paramètres doivent être attribués des valeurs lors de l'utilisation d'annotations personnalisées, sinon le compilateur rapportera une erreur.
Jetez un œil au code utilisé par l'annotation:
@ClassInfo (auteur = "wang", date = "2016/9/13", commentaire = "Demo annotation") Classe publique AnnotationDemo {@FieldInfo (type = "public", name = "Firstfield") public int FirstField; @FieldInfo (type = "private", name = "secondfield") String privé secondfield; @MethodInfo (description = "Méthode dans AnnotationDemo", name = "FirstMethod") public void firstMethod (String Value) {System.out.printf ("Première méthode impliquée"); } @MethodInfo (Description = "Méthode dans AnnotationDemo", name = "SecondMethod") private void secondMethod () {System.out.printf ("première méthode impliquée"); }}Obtenir des informations d'annotation
Pour obtenir des informations d'annotation, nous devons d'abord nous assurer que l'annotation existera pendant l'exécution du programme. Par conséquent, nous ajoutons généralement la méta-annotation @retention (retentionPolicy.runtime) en annotations personnalisées. De cette façon, pendant l'exécution du programme, nous pouvons obtenir des informations d'annotation par la réflexion. Pour des instructions sur la réflexion, vous pouvez voir cet article.
classe publique AnnotationTest {public static void main (String [] args) {résolveclassannotationInfo (annotationdemo.class); ResolveFieldannotationInfo (annotationdemo.class); ResolvemethodannotationInfo (annotationdemo.class); } private static void résolveclassannotationInfo (class <?> clz) {// déterminer si cette classe a une annotation classinfo if (clz.isannotationPresent (classinfo.class)) {classinfo classinfo = (classinfo) clz.getannotation (classinfo.class); System.out.println (classinfo.author () + "" + classinfo.comments () + "" + classinfo.date ()); }} private static void résolufieldannotationInfo (class <?> clz) {field [] fields = clz.getDeclaredFields (); pour (champ de champ: champs) {if (field.isannotationPresent (fieldInfo.class)) {fieldInfo fieldInfo = (fieldInfo) field.getAnTannotation (fieldInfo.class); System.out.println (fieldInfo.Type () + "" + fieldInfo.Name ()); }}} private static void résolvemethodannotationInfo (class <?> clz) {méthode [] méthodes = clz.getDeclaredMethods (); pour (méthode méthode: méthodes) {if (method.isannotationPresent (methodInfo.class)) {méthodeInfo methodinfo = (methodInfo) metheth.getAnTannotation (methodinfo.class); System.out.println (Methodinfo.Name () + "" + MethodInfo.Description ()); }}}}Réflexion pour obtenir un champ / méthode dans la classe, etc., et obtenir des annotations pertinentes via Getannotation () ou GetAnnotations (). Vous pouvez obtenir des informations spécifiques en obtenant les annotations spécifiques.
La sortie du résultat d'exécution est la suivante:
Diagramme de résultats de l'opération Figure-1
Résumer
Pour les débutants de Java et même des développeurs Java avec une certaine expérience, ils peuvent avoir moins d'exposition aux annotations Java. En réalité, les annotations sont rarement utilisées, mais elles les verront souvent dans le code. Cet article est une simple introduction aux annotations, et au moins au niveau du code, il est sans stress à lire.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.