1. Présentation
Les annotations peuvent être définies sur les méthodes.
Annotations couramment utilisées:
@Override: signifie une méthode pour rediffuser la classe,
Cela peut également déterminer si la méthode de la classe parent est écrasée. Méthode de la classe parent qui est écrasée.
@SuppressWarnings ("Deprécation"): annuler l'avertissement du compilateur (par exemple, la méthode que vous utilisez est obsolète)
@Deprecated: Cette déclaration est également placée en haut de la méthode, indiquant que cette méthode est obsolète ou utilisée sur la classe
La copie de code est la suivante:
import java.util.arraylist;
Importer java.util.list;
classe publique AnnotationDemo {
/ *
* Pour les collections, si aucun type de stockage n'est spécifié, il y aura un avertissement de sécurité.
* Si vous ne souhaitez pas inviter un avertissement de sécurité, ajoutez @SuppressWarnings (paramètre) à la classe ou à la méthode.
* /
@SuppressWarnings ("non contrôlé")
public static void main (String [] args) {
List list = new ArrayList ();
}
}
2. Annotations personnalisées
1. Format
Permissions @Interface Annotation Name {}
étape:
Définir la classe d'annotation ---> Définir la classe de la classe d'annotation d'application ---> Classe qui reflète la classe de la classe d'annotation d'application (cette classe peut être définie séparément ou testée dans la classe d'annotation d'application)
La copie de code est la suivante:
import java.lang.annotation.retention;
importjava.lang.annotation.retentionPolicy;
// Définissez cette annotation à conserver en bytecode
@Retention (RetentionPolicy.runtime)
public @interface myannotation {
}
@Myannotation
// classe d'annotation définie par l'application
classe publique appliquemyannotation {
public static void main (String [] args) {
if (applicationmyannotation.class.isannotationPresent (myannotation.class)) {// Déterminez s'il existe une classe d'annotation spécifiée sur cette classe
Myannotation Annotation = (Myannotation) ApplyMyannotation.class
.GetAnnotation (Myannotation.class);
System.out.println (annotation);
}
}
}
2. Cycle de déclaration
Format: par exemple: @retention (RetentionPolicy.class)
Définir les cycles sur une classe d'annotation personnalisée, le type de paramètre @retention (type de paramètre) est rétentionPolicy
RetentionPolicy.class: Sur le fichier de classe, la machine virtuelle ne conserve pas les annotations pendant l'exécution
RetenderPolicy.runtime: Dans le fichier de classe, les commentaires virtuels sont conservés pendant l'exécution.
RetenderPolicy.source: sur le fichier source, jetez l'annotation
Supprimwarnings and Override est la rétentionPolicy.source,
Dégréé est dans la retenue-Polite.
La valeur par défaut est RetentionPolicy.class:
3. Spécifiez la cible
Format: par exemple: méthode @target (elementType.Method)
Quels membres peuvent être annotés par l'annotation définie. Si cette annotation n'est pas déclarée, elle peut être placée sur n'importe quel élément de programme.
Il peut s'agir de packages, d'interfaces, de paramètres, de méthodes, de variables locales, de champs, etc.
La copie de code est la suivante:
// Définissez cette annotation à conserver en bytecode
@Retention (RetentionPolicy.runtime)
@Target ({elementType.Method, elementType.Type}) // Il peut être défini sur les méthodes et les classes pour représenter les types
public @interface myannotation {
}
@Myannotation
// classe d'annotation définie par l'application
classe publique appliquemyannotation {
@ Myannotation // défini sur la méthode
public static void main (String [] args) {
if (applicationmyannotation.class.isannotationPresent (myannotation.class)) {// Déterminez s'il existe une classe d'annotation spécifiée sur cette classe
Myannotation Annotation = (Myannotation) ApplyMyannotation.class
.GetAnnotation (Myannotation.class);
System.out.println (annotation);
}
}
}
3. Ajouter des attributs à l'annotation
1. Type
Les paramètres d'attribut des annotations peuvent être: 8 types de données de base, chaîne, énumération, annotation, classe, types de tableau,
2. Faites attention
S'il n'y a qu'un seul attribut dans l'annotation ou qu'un seul attribut doit être attribué, il peut être écrit directement lorsqu'il est appelé sans spécifier le nom d'attribut.
Lorsque l'attribut annoté est un type de tableau et qu'une seule valeur est attribuée lors de l'attribution, {} peut être omise.
3. Exemple
3.1.Attribute Type (IS String)
La copie de code est la suivante:
import java.lang.annotation.elementType;
import java.lang.annotation.retention;
Importer java.lang.annotation.retentionPolicy;
import java.lang.annotation. *;
// Définissez cette annotation à conserver en bytecode
@Retention (RetentionPolicy.runtime)
public @interface myannotation {
String value ();
String color () par défaut "rouge"; // définir la valeur par défaut est "rouge"
}
@Myannotation ("Java")
classe publique appliquemyannotation {
public static void main (String [] args) {
/ **
* Il s'agit d'obtenir l'annotation sur la classe, et vous pouvez également obtenir l'annotation sur la méthode.
* /
if (applicationmyannotation.class.isannotationPresent (myannotation.class)) {// Déterminez s'il existe une classe d'annotation spécifiée sur cette classe
Myannotation Annotation = (Myannotation) ApplyMyannotation.class
.GetAnnotation (Myannotation.class);
System.out.println ("value =" + annotation.value ());
System.out.println ("color =" + annotation.color ());
}
}
}
résultat:
valeur = java
Couleur = rouge
Dans le programme d'appel, on peut également voir que si un seul attribut peut être attribué, le nom d'attribut peut être omis. Sinon @ Classe Annotation (name d'attribut = valeur)
3.2.
La copie de code est la suivante:
/ * Enum Class * /
Semaine publique de l'énumération {
Soleil, lundi;
}
/ **
* Classe d'annotation
* /
public @Interface AnnotationText {
String value ();
}
import java.lang.annotation.elementType;
import java.lang.annotation.retention;
Importer java.lang.annotation.retentionPolicy;
import java.lang.annotation. *;
// Définissez cette annotation à conserver en bytecode
@Retention (RetentionPolicy.runtime)
public @interface myannotation {
String value ();
String color () par défaut "rouge"; // définir la valeur par défaut est "rouge"
Semaine semaine () semaine par défaut.Mon; // Type d'énumération
int [] array () par défaut {1,2,3}; // Type de tableau
AnnotationText Annotation () par défaut @AnnotationText ("My");
Classe classDemo () Integer.class par défaut; // Type de classe
}
@Myannotation (value = "java", color = "green", semaine = semaine.sun, array = 5, annotation = @ annotationText ("vous"), classdemo = string.class) // array = {4,5, 6}
classe publique appliquemyannotation {
public static void main (String [] args) {
/ **
* Il s'agit d'obtenir l'annotation sur la classe, et vous pouvez également obtenir l'annotation sur la méthode.
* /
if (applicationmyannotation.class.isannotationPresent (myannotation.class)) {// Déterminez s'il existe une classe d'annotation spécifiée sur cette classe
Myannotation Annotation = (Myannotation) ApplyMyannotation.class
.GetAnnotation (Myannotation.class);
System.out.println ("value =" + annotation.value ());
System.out.println ("color =" + annotation.color ());
System.out.println ("semaine =" + annotation.week ());
System.out.println ("Array Length =" + Annotation.Array (). Length);
System.out.println ("Annotation Type Value =" + Annotation.annotation (). Value ());
System.out.println ("Class Type Value =" + Annotation.ClassDemo ());
}
}
}
résultat:
La copie de code est la suivante:
valeur = java
Couleur = vert
semaine = soleil
Longueur du tableau = 1
Valeur du type d'annotation = vous
Class Type Value = classjava.lang.string
4. Annotations sur la méthode
La copie de code est la suivante:
importjava.lang.annotation.retention;
importjava.lang.annotation.retentionPolicy;
/ **
* Classe d'annotation
* /
@Retention (RetentionPolicy.runtime)
public @Interface AnnotationText {
StringValue ();
}
publicClassApplyMyannotation {
publicStaticVoidMain (String [] args) throwSException {
MethodMethoDshow = applicationmyannotation.class.getMethod ("Show");
annotationTextAnno = methodshow.getAnnotation (annotationText.class);
System.out.println (anno.value ());
}
@AnnotationText ("Java")
publicVoidShow () {
System.out.println ("Hello");
}
}
Résultats: Java