annotation
1. Qu'est-ce que l'annotation? (Annotation ou commentaires)
Annotation, la traduction précise devrait être - l'annotation. C'est complètement différent des commentaires.
L'annotation est une fonctionnalité introduite par JDK5.0 et versions ultérieures. Il est au même niveau que les classes, les interfaces et les énumérations et peut devenir un type de java.
La syntaxe commence par @,
Les commentaires sont une mémorisation ou des descriptions rapides faites par les programmeurs des classes de code source, des méthodes, des propriétés, etc. (comme pour quoi cette méthode est utilisée), et sont pour les gens.
L'annotation est la partie que le compilateur Java peut comprendre et est pour le compilateur.
Donnons un exemple simple pour voir l'utilisation et la fonction des annotations.
@Override est une annotation intégrée Java commune. Sa fonction est de vérifier si les méthodes définies dans la sous-classe sont correctes lors de la compilation du code.
Annotation du package; Classe abstraite publique Animal {public abstrait void Eat (); } Annotation du package; classe publique Cat étend l'animal {@Override public void Eat (String Food) {}} Ici, dans la sous-classe Cat, la méthode EAT est annotée comme une méthode qui écrase la classe parent, mais elle a un paramètre de plus que la méthode de la classe parent.
Si vous éditez dans Eclipse, il y aura une invite de la Croix-Rouge. (La compilation de code ne sera pas adoptée).
Si vous supprimez l'annotation @Override, il n'y a pas de problème avec la compilation, mais la méthode EAT dans CAT est une nouvelle méthode de cette classe, non héritée de la classe parent.
2. Annotations intégrées java communes
Y compris @Override, quelles autres annotations intégrées Java communes?
1. @Deprecated
L'annotation n'est pas recommandée et peut être utilisée sur les méthodes et les classes.
Fondamentalement, cette méthode et cette classe sont abandonnées et non recommandées pour certaines raisons telles que la mise à niveau ou les performances, mais doivent être conservées pour la compatibilité ou d'autres raisons.
Alors, mettez cette annotation dessus.
Il existe de nombreux exemples de ce type dans l'API Java lui-même. Si vous mettez cette annotation sur la méthode, vous verrez quelle est la nouvelle méthode alternative.
Lors de l'écriture de code dans Eclipse, la méthode qui ajoute cette annotation ajoutera des strikethroughs à la déclaration et à l'appel.
2. @ remplacer
3. @ Supprimwarnings
Ignorer les avertissements.
Si votre code a des avertissements dans la transformation ou d'autres parties, mais que vous souhaitez ignorer ces avertissements, vous pouvez utiliser cette annotation.
1) Avertissement lorsque la dépréciation utilise une classe ou une méthode qui n'est pas favorisée
2) AVERTISSEMENT non contrôlé lorsque la conversion non contrôlée est effectuée
3) Les avertissements de chute apparaissent lorsque l'opération de rupture n'est pas ajoutée après l'utilisation de l'affaire, ce qui a permis de continuer à exécuter d'autres instructions de cas
4) Avertissement de chemin lors de la définition d'un chemin de chemin de classe ou d'un chemin de fichier source incorrect
5) AVERTISSEMENT SÉRAVELLE Lorsque la définition de SerialVersionUid est manquante sur la classe sérialisable
6) AVERTISSEMENT FIANALEMENT Si une clause enfin ne peut être terminée normalement
7) Tous les avertissements de toutes les situations ci-dessus
3. Annotations personnalisées
En plus des annotations intégrées fournies par Java elle-même, Java offre également la fonction de personnalisation des annotations personnalisées.
La façon de définir les annotations est d'utiliser des annotations pour définir les annotations. Les annotations utilisées pour définir les annotations sont appelées méta-annotations.
Les principales annotations de méta sont les suivantes: @Target; @Rétention; @Documenté; @Hérité
1. @Target indique où l'annotation est utilisée et peut être utilisée sur les classes, les méthodes ou les attributs. Les paramètres ElemeNetType possibles comprennent:
ElemenetType.Contructor Constructor Déclaration
Déclaration de domaine ElemeNetType.Field (y compris les instances d'énumération)
Elemenettype.local_variable Déclaration de variables locales
Déclaration de méthode elemenetType.Method
Énoncé du package elemenetType.Package
Déclaration de paramètres ElemeNetType.Parameter
Classe ElemeNetType.Type, interface (y compris le type d'annotation) ou Déclaration d'énumération
2. @Retention indique quel niveau pour sauver les informations d'annotation. Les paramètres de rétention de rétention facultatif comprennent:
RetentionPolicy.La annotation de la source sera rejetée par le compilateur
RetenderPolicy.class Annotation est disponible dans le fichier de classe, mais sera rejeté par la machine virtuelle.
RetentionPolicy.Runtime VM conservera également des commentaires pendant l'exécution, de sorte que les informations d'annotation peuvent être lues dans le mécanisme de réflexion.
3. @Documented, s'il faut inclure cette annotation lors de la génération de DOC, incluez cette annotation en Javadoc
4. @Inherited
Laissez les sous-classes hériter des annotations de la classe parent voient quelques exemples de définition simples:
Annotation du package; import java.lang.annotation.documented; import java.lang.annotation.elementType; Importer java.lang.annotation.herited; import java.lang.annotation.retention; Importer java.lang.annotation.retentionPolicy; import java.lang.annotation.target; @Target (elementType.Method) public @Interface Myannotation {String Value (); } @Retention (RetentionPolicy.Source) @Interface Myannotation1 {} @retention (RetenderPolicy.class) @Interface Myannotation2 {} @retention (RetendantPolicy.Runtime) @Interface Myannotation3 {} @Documented @interface Myannotation4 {} @inherited @interface myannotation5 {}4. Utiliser des exemples:
Annotation du package; import java.lang.annotation.annotation; @ Myannotation3 public class Testannotation {public static void main (String [] args) {// TODO Méthode auto-générée Stub Annotation Annotation = Testannotation.class.getannotation (myannotation3.class); System.out.println (annotation.toString ()); }} Imprimez le résultat: @ annotation.myannotation3 ()
Si Myannotation1 et Myannotation2 sont remplacés dans l'exemple ci-dessus, la valeur de l'annotation obtenue est vide, ce qui est la différence entre la politique de rétention.
V. Le rôle de l'annotation
À ce stade, nous pouvons résumer le rôle de l'annotation.
Les bases peuvent être à peu près divisées en trois catégories:
1. Écrivez un document
2. Analyse du code
3. Vérification de la compilation Cependant, les frameworks open source lui donnent plus de fonctions, telles que:
Hibernate, configuration d'annotation,
@Column ("aa") String privé xx; Ceci est similaire à la configuration XML, qui simplifie la configuration du programme et déplace une partie des métadonnées du fichier XML au code lui-même, et le gère et le maintient en un seul endroit.
Comment est-il implémenté en interne? - Mécanisme de réflexion Java, similaire à l'exemple ci-dessus.
Commentaires
Bien que les annotations et les commentaires ne soient qu'un mot différent, l'utilisation est très différente.
La même phrase est vraie, les annotations sont pour le compilateur à voir, et les annotations sont que les gens peuvent voir.
Sur la base de cela, pour une méthode:
1. Décrivez simplement la fonction de cette méthode clairement, entrée et sortie. Vous pouvez ajouter plus d'informations telles que les auteurs et les versions.
2. Faites simplement ces deux choses avec un bel arrangement de commentaires. Par exemple:
/ *********************************************************************************************************************** * Nom: Utilisation * Description: V0.1: N / A * RETOUR: * Auteur: Oscar999 * version: V0.1 ****************************************************************************************
Il semble que ce soit une bonne note ^^.
Mais pour la langue java, les commentaires reçoivent plus de fonctions. Autrement dit, vous pouvez utiliser la fonction Javadoc pour exporter des commentaires dans le code vers le fichier HTML.
Si votre code est un code avec une forte majorité, ce document est un document de référence API, similaire à l'API Java.
Par conséquent, pour générer un tel document, vous devez suivre certaines spécifications d'annotation définies par Java afin de produire un document standardisé.
1. Commentaires standard sur les méthodes de classe Java
Commençons par les commentaires sur la méthode de la classe.
/ ** * Lisez une ligne de texte. Une ligne est considérée comme résiliée par n'importe quel * aliment de ligne ('/ n'), un retour chariot ('/ r'), ou un retour chariot * suivi immédiatement par une alimentation. * * @param ignorelf1 Si true, le prochain '/ n' sera sauté <pre code_snippet_id = "74911" snippet_file_name = "blog_20131120_2_8365599" name = "code"> * @param ignorelf2 si true, la prochaine '/ n' ne sera pas stimulée </ pre> * * @return a une chaîne Continent à la ligne de la ligne de l'inclusion </ pre> * * * @retRn a une chaîne Continent la ligne de la ligne de la ligne de la ligne, de la gamme </ Pre> * * * @retRn a une chaîne Continent à la ligne de la ligne de la ligne de la ligne, de la ligne, de la gamme </ Pre> * * * @retRn a une chaîne CONTRAINT CONTENTS de la ligne de la ligne de la ligne, de la gamme </ Pre> * * * @retRn a une chaîne CONTRAIN Tous les caractères de terminaison de ligne, ou null si la fin du * flux a été atteint * * @see java.io.lineNumberReader # readLine () * * @Exception ioexception Si une erreur d'E / S se produit * / / (Ne faites pas attention à la signification des commentaires ci-dessus, concentrez-vous simplement sur le style de sa définition)
1. Regardez d'abord le haut "Lisez une ligne de texte. Une ligne ..". Ce paragraphe est une description de cette méthode.
La partie avant la première période, qui est "Lire une ligne de texte". apparaîtra dans "Résumé de la méthode"
2. @Param définit les paramètres d'entrée de la méthode, qui (multiple peut être ajouté) apparaît dans "Détails de la méthode". (Le paramètre et la description du paramètre sont séparés par des espaces et convertis en - dans le document généré)
3. @Return Description de la valeur de retour
4. @see Description de référence
5. La description de @Exception lancée par exception est magnifique. Différents types de balises peuvent être affichés en une seule ligne, tels que @param et @return directement vide une ligne.
2. Commentaires standard de la classe Java
Le format d'annotations de classe et d'annotations de méthode est fondamentalement le même. Quelle est la différence:
1. Le placement est différent. Les annotations de classe sont placées au-dessus de la définition de classe et les annotations de la méthode sont placées au-dessus de la définition de la méthode.
2. La comparaison de l'annotation de classe utilise des balises comme @version @author @Since.
Regardez le modèle
/ **ra tamponra l'entrée du fichier spécifié. Sans tampon, chaque * invocation de read () ou readLine () pourrait entraîner la lecture des octets à partir du fichier *, converti en caractères, puis retourné, qui peut être très * inhérent. * * Description du test * * <p> Les programmes qui utilisent DatainputStreams pour l'entrée textuelle peuvent être localisés en remplaçant chaque DataRainPutStream par un BufferedReader approprié. * * @see fileReader * @see inputStreamReader * * @version 0.1, 11/20/13 * @Author Oscar999 * @Since JDK1.5 * /
Les effets affichés dans DOC sont:
De même, la première phrase de la description apparaît dans le "classification".
Les détails de la classe sont affichés comme suit:
Il convient de noter que l'utilisation de <p> dans la description. Si <p> n'est pas ajouté, qu'il y ait une nouvelle ligne dans le code Java, le DOC généré ne sera pas nouveau. Si <p> est ajouté, une nouvelle ligne apparaît dans DOC.
3. Compléter
Pour ajouter, la méthode pour générer Javadoc:
1. Méthode de ligne nommée: Javadoc + Paramètres
2. Utilisez l'IDE Eclipse pour exporter si dans l'Eclipse IDE, cliquez avec le bouton droit sur le fichier source ou le projet, sélectionnez Exporter --->
Java -> Javadoc peut être généré.