Maison >Java >javaDidacticiel >Cours d'apprentissage sur les pensées de programmation Java (7) Chapitre 20 - Notes

Cours d'apprentissage sur les pensées de programmation Java (7) Chapitre 20 - Notes

php是最好的语言
php是最好的语言original
2018-08-09 14:59:021368parcourir

 annotations (également connues sous le nom de métadonnées) nous fournissent ajout d'informations au code Un formel Une méthode est développée qui nous permet d'utiliser ces données très facilement ultérieurement.

1 Syntaxe de base

  Les méthodes annotées ne sont pas différentes des autres méthodes. Les annotations peuvent être utilisées avec n'importe quel modificateur sur une méthode, par exemple public, static ou void. Du point de vue syntaxique, les annotations sont utilisées presque exactement comme des modificateurs.

1.1 Définition des annotations

  La définition des annotations ressemble beaucoup à la définition des interfaces. En fait, comme toute autre interface Java, les annotations seront également compilées dans des fichiers de classe .

  Lors de la définition des annotations, vous aurez besoin de méta-annotations (méta-annotation) , telles que @Target, @Retention.

  Dans les annotations, généralement contient quelques éléments pour représenter certaines valeurs . Un programme ou un outil peut utiliser ces valeurs lors de l'analyse et du traitement des annotations. Les éléments annotés ressemblent à des méthodes d'interface, la seule différence est que vous pouvez leur attribuer des valeurs par défaut. Il existe des restrictions sur les types d'éléments.

  Une annotation sans éléments est appelée une annotation de marqueur .

  Toutes les annotations héritent de annotation.

package net.mrliuli.annotations;import java.lang.annotation.*;@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface Test {} //(marker annotation)

1.2 Trois annotations standards et quatre méta-annotations

  Trois annotations standards définies dans java.lang :

  • @ Remplacé

  • @Obsolète

  • @SuppressWarnings

Quatre méta-annotations :

  • @Target indique où cette annotation peut être utilisée.

  • @Retension indique à quel niveau les informations d'annotation doivent être enregistrées.

  • @Documenté Incluez cette annotation dans Javadoc.

  • @Inherited permet aux sous-classes d'hériter des annotations des classes parentes.

1.3 À propos des annotations

  • Le type des éléments d'annotation est limité et ne peut pas être de n'importe quel type. L'utilisation d'un type autre que le type autorisé entraînera. le compilateur pour signaler une erreur.

  • Restrictions de valeur par défaut :

    @Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface SimulationNull{
        public int id() default -1;    public String description() default "";
    }
    • Premièrement, les éléments ne peuvent pas avoir de valeurs indéterminées. Autrement dit, l'élément doit avoir une valeur par défaut ou fournir la valeur de l'élément lors de l'utilisation de l'annotation.

    • Deuxièmement, pour les éléments de types non basiques, null ne peut pas être utilisé comme valeur, que ce soit lors de sa déclaration dans le code source ou lors de la définition d'une valeur par défaut dans une interface d'annotation . Cette contrainte rend difficile pour un processeur d'annotation de représenter la présence ou l'absence d'un élément, car dans chaque déclaration d'annotation, tous les éléments sont présents et ont des valeurs correspondantes. Afin de contourner cette contrainte, on ne peut définir que quelques valeurs particulières comme des chaînes vides ou des nombres négatifs pour indiquer qu'un élément n'existe pas :

  • Générer un élément externe fichiers. Certains frameworks nécessitent des informations supplémentaires pour fonctionner avec votre code source, et dans ce cas, les annotations sont les mieux adaptées pour exprimer leur valeur. Les technologies telles que Enterprise JavaBeans nécessitent des fichiers de description de déploiement. Les services Web, les bibliothèques de balises personnalisées et les outils de mappage objet/relationnel (tels que Toplink et Hibernate) nécessitent généralement des fichiers de description XML, et ces fichiers de description sont séparés du code source.

2 Écriture d'un processeur d'annotations

  Une partie importante du processus d'utilisation des annotations consiste à créer et à utiliser un processeur d'annotations , permet de lire l'annotation .

  • L'API du mécanisme de réflexion peut construire un processeur d'annotations

  • L'outil externe apt peut analyser le code source Java avec des annotations

Articles connexes :

Leçon d'apprentissage de la pensée en programmation Java (5) Chapitre 18 - Système IO Java

Apprentissage de la pensée en programmation Java Leçon (6) Chapitre 19 - Type d'énumération

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!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn