1. Descripción general
Las anotaciones se pueden definir en métodos.
Anotaciones de uso común:
@Override: significa un método para volver a parecer la clase,
Esto también puede determinar si el método de la clase principal está sobrescribida. Método de la clase principal que se sobrescribe.
@SupessWarnings ("Depreción"): Cancele la advertencia del compilador (por ejemplo, el método que está utilizando está desactualizado)
@Depreced: esta declaración también se coloca en la parte superior del método, lo que indica que este método está desactualizado o utilizado en la clase
La copia del código es la siguiente:
import java.util.arrayList;
import java.util.list;
AnnotationDemo de clase pública {
/*
* Para colecciones, si no se especifica ningún tipo de almacenamiento, habrá una advertencia de seguridad.
* Si no desea obtener una advertencia de seguridad, agregue @suppleswarnings (parámetro) a la clase o método.
*/
@SupessWarnings ("sin control")
public static void main (string [] args) {
List List = new ArrayList ();
}
}
2. Anotaciones personalizadas
1. Formato
Permisos @interface Nombre de anotación {}
paso:
Definir clase de anotación ---> Definir la clase de la clase de anotación de la aplicación ---> Clase que refleja la clase de la clase de anotación de la aplicación (esta clase se puede definir por separado o probarse en la clase de anotación de la aplicación)
La copia del código es la siguiente:
import java.lang.annotation.retention;
importJava.lang.annotation.RetentionPolicy;
// Defina esta anotación que se mantendrá en bytecode
@Retention (retenciónPolicy.Runtime)
public @Interface MyAnnotation {
}
@Myannotation
// Clase de anotación definida por la aplicación
clase pública ApplyMyannotation {
public static void main (string [] args) {
if (applymyannotation.class.isannotationPresent (myAnnotation.class))) {// Determine si hay una clase de anotación especificada en esta clase
Anotación de myAnnotation = (myAnnotation) Aplicarmyannotation.class
.getAnnotation (myAnnotation.class);
System.out.println (anotación);
}
}
}
2. Ciclo de declaración
Formato: Por ejemplo: @Retention (retenciónPolicy.Class)
Definir ciclos en una clase de anotación personalizada, el tipo de parámetro @Tretention (Tipo de parámetro) es retención
RetentionPolicy.class: en el archivo de clase, la máquina virtual no conserva las anotaciones durante el tiempo de ejecución
RetenciónPolicy.Runtime: en el archivo de clase, los comentarios virtuales se conservan durante el tiempo de ejecución.
RetenciónPolicy.source: en el archivo fuente, descarte la anotación
Supresswarnings y anulación son retención de la capacidad.
Deprecido está en retención.
El valor predeterminado es retenciónPolicy.class:
3. Especifique el objetivo
Formato: por ejemplo: método @Target (elementtype.method)
Qué miembros pueden ser anotados por la anotación definida. Si esta anotación no se declara, se puede colocar en cualquier elemento de programa.
Puede ser paquetes, interfaces, parámetros, métodos, variables locales, campos, etc.
La copia del código es la siguiente:
// Defina esta anotación que se mantendrá en bytecode
@Retention (retenciónPolicy.Runtime)
@Target ({elementtype.method, elementtype.type}) // se puede definir en métodos y clases para representar tipos
public @Interface MyAnnotation {
}
@Myannotation
// Clase de anotación definida por la aplicación
clase pública ApplyMyannotation {
@MyAnnotation // definido en el método
public static void main (string [] args) {
if (applymyannotation.class.isannotationPresent (myAnnotation.class))) {// Determine si hay una clase de anotación especificada en esta clase
Anotación de myAnnotation = (myAnnotation) Aplicarmyannotation.class
.getAnnotation (myAnnotation.class);
System.out.println (anotación);
}
}
}
3. Agregar atributos a la anotación
1. Tipo
La configuración de atributos de las anotaciones puede ser: 8 tipos de datos básicos, cadena, enumeración, anotación, clase, tipos de matriz,
2. Presta atención
Si solo hay un atributo en la anotación o solo se debe asignar un atributo, entonces se puede escribir directamente cuando se llama sin especificar el nombre del atributo.
Cuando el atributo anotado es un tipo de matriz y solo se asigna un valor al asignar, {} se puede omitir.
3. Ejemplo
3.1. Tipo de attribido (es cadena)
La copia del código es la siguiente:
import java.lang.annotation.ElementType;
import java.lang.annotation.retention;
import java.lang.annotation.retentionPolicy;
import java.lang.annotation.*;
// Defina esta anotación que se mantendrá en bytecode
@Retention (retenciónPolicy.Runtime)
public @Interface MyAnnotation {
Valor de cadena ();
Cadena color () predeterminado "rojo"; // Establecer el valor predeterminado es "rojo"
}
@Myannotation ("java")
clase pública ApplyMyannotation {
public static void main (string [] args) {
/**
* Esto es para obtener la anotación en la clase, y también puede obtener la anotación en el método.
*/
if (applymyannotation.class.isannotationPresent (myAnnotation.class))) {// Determine si hay una clase de anotación especificada en esta clase
Anotación de myAnnotation = (myAnnotation) Aplicarmyannotation.class
.getAnnotation (myAnnotation.class);
System.out.println ("value ="+annotation.value ());
System.out.println ("color ="+annotation.color ());
}
}
}
resultado:
valor = java
Color = rojo
Desde el programa de llamadas, también se puede ver que si solo se puede asignar un atributo, se puede omitir el nombre del atributo. De lo contrario, @ class de anotación (nombre del atributo = valor)
3.2.
La copia del código es la siguiente:
/*Clase enum*/
Public Enum Week {
Sol, lun;
}
/**
* Clase de anotación
*/
public @interface AnnotationText {
Valor de cadena ();
}
import java.lang.annotation.ElementType;
import java.lang.annotation.retention;
import java.lang.annotation.retentionPolicy;
import java.lang.annotation.*;
// Defina esta anotación que se mantendrá en bytecode
@Retention (retenciónPolicy.Runtime)
public @Interface MyAnnotation {
Valor de cadena ();
Cadena color () predeterminado "rojo"; // Establecer el valor predeterminado es "rojo"
Semana de la semana () Predeterminado Semana.mon; // Tipo de enum
int [] array () predeterminado {1,2,3}; // Tipo de matriz
AnnotationText Annotation () predeterminado @AnnotationText ("my");
Class ClassDemo () default integer.class; // tipo de clase
}
@Myannotation (valor = "java", color = "verde", week = week.sun, array = 5, annotation =@annotationText ("you"), classDemo = string.class) // array = {4,5, 6}
clase pública ApplyMyannotation {
public static void main (string [] args) {
/**
* Esto es para obtener la anotación en la clase, y también puede obtener la anotación en el método.
*/
if (applymyannotation.class.isannotationPresent (myAnnotation.class))) {// Determine si hay una clase de anotación especificada en esta clase
Anotación de myAnnotation = (myAnnotation) Aplicarmyannotation.class
.getAnnotation (myAnnotation.class);
System.out.println ("value ="+annotation.value ());
System.out.println ("color ="+annotation.color ());
System.out.println ("week ="+annotation.week ());
System.out.println ("Array Longitud ="+Annotation.Array (). Longitud);
System.out.println ("Annotation Type Value ="+Annotation.Annotation (). Value ());
System.out.println ("class type value ="+annotation.classDemo ());
}
}
}
resultado:
La copia del código es la siguiente:
valor = java
Color = verde
Semana = Sol
Longitud de la matriz = 1
Valor de tipo de anotación = usted
Valor de tipo de clase = classJava.lang.String
4. Anotaciones sobre el método
La copia del código es la siguiente:
importjava.lang.annotation.retention;
importJava.lang.annotation.RetentionPolicy;
/**
*Clase de anotación
*/
@Retention (retenciónPolicy.Runtime)
public @interface AnnotationText {
StringValue ();
}
PublicClassApplyMyannotation {
publicstaticvoidmain (string [] args) throwsexception {
MethodMethodshow = ApplyMyAnnotation.class.getMethod ("show");
anotationTextanno = Methodshow.getAnnotation (annotationText.class);
System.out.println (anno.value ());
}
@AnnotationText ("Java")
publicvoidshow () {
System.out.println ("hola");
}
}
Resultados: Java