java: anotaciones

que es anotación

La anotación es un nuevo tipo de datos, que es muy similar a la interfaz y está al mismo nivel que la clase, la interfaz y la enumeración.

Equivalente a una marca, comenzando con @, puede declarar el frente de clases, propiedades, métodos, parámetros, etc. Se utiliza para describir, etiquetar e implementar funciones específicas para elementos.

Función:
1. Escribir documentos: generar documentos de acuerdo con las anotaciones
2. Análisis de código: analizar el código utilizando la reflexión a través de anotaciones
3. Inspección de la compilación: permitir que el compilador implemente la verificación de tipo básica a través de anotaciones, como Override

Anotaciones predefinidas de JDK

en el paquete java.lang

anotación	efecto
@Anular	Delante del método, anule el método de la clase principal
@Obsoleto	Frente a clases, atributos y métodos, significa desactualizado y no recomendado.
@SuppressWarning	Delante de clases, atributos y métodos, significa cerrar el mensaje de advertencia.

package cn.xxx.annotation;

import java.util.Date;

@SuppressWarnings("all")
public class AnnoDemo2 {
    
    

    @Override
    public String toString() {
    
    
        return super.toString();
    }

    @Deprecated//过期注解
    public void show1(){
    
    
        //有缺陷
    }

    public void show2(){
    
    
        //替代show1方法
    }

    public void demo(){
    
    
        show1();
        Date date = new Date();
    }
}

anotación personalizada

Usando @interface+ meta-anotaciones

// 元注解
public @interface 注解名 {
    
    
	// 抽象方法或者叫属性列表
}

Meta-anotaciones: Anotaciones etiquetadas en anotaciones

anotación meta	efecto
@Objetivo	Defina el alcance de las anotaciones, es decir, qué elementos se pueden marcar, como clases, métodos, etc. Cuando se omite, puede estar antes de cualquier elemento.
@Retención	Definir el ciclo de vida de las anotaciones, SOURCE, CLASS, RUNTIME, mantener en compilación, mantener en la clase, generalmente usar RUNTIME
@Documentado	Ya sea para incluir anotaciones al generar documentación usando javadoc
@Heredado	Permitir que las subclases hereden las anotaciones de la clase principal

Las anotaciones finalmente se compilan para:

public interface MyAnno extends java.lang.annotation.Annotation {
    
    }

Entonces, la esencia de la anotación es una interfaz, que hereda la interfaz de anotación de forma predeterminada.

package cn.xxx.annotation;

import java.lang.annotation.*;

@Target({
    
    ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {
    
    
}

Usar anotaciones

gramática:

@注解名(属性名=属性值,属性名=属性值)

• Al usar anotaciones, debe especificar el valor de retorno para el método abstracto en la anotación, también conocido como especificar el valor de la propiedad para la anotación.
• El nombre del atributo es el nombre del método abstracto en la anotación

package cn.xxx.annotation;

public @interface MyAnno {
    
    

     int value();
     Person per();
     MyAnno2 anno2();
     String[] strs();
     /*String name() default "张三";*/
     /*String show2();

     Person per();
     MyAnno2 anno2();

     String[] strs();*/
}

package cn.xxx.annotation;

@MyAnno(value=12,per = Person.P3,anno2 = @MyAnno2,strs={
    
    "bbb","aaa"})
@MyAnno3
public class Worker {
    
    
    @MyAnno3
    public String name = "aaa";
    @MyAnno3
    public void show () {
    
    
    }
}

análisis de anotaciones

Para anotaciones cuyo ciclo de vida es RUNTIME. Analizar anotaciones es obtener los valores de atributos definidos en las anotaciones. Hay tres pasos:

1. Obtenga el objeto de la ubicación (Clase, Método, Campo) definido por la anotación
2. Obtener la anotación especificada
   • obtener anotación (clase)

   //其实就是在内存中生成了一个该注解接口的子类实现对象
   public class ProImpl implements Pro{
         
         
       public String className(){
         
         
           return "cn.itcast.annotation.Demo1";
       }
       public String methodName(){
         
         
           return "show";
       }
   }
   

3. Llame al método abstracto en la anotación para obtener el valor del atributo configurado.

Ejemplo:

// 1、获取类上的注解
Class cls = Student.class;
// 2、获取该类Student上的所有注解，不一定获取类上的注解，也可以获取方法上的注解，这时候就是 `method.getAnnotation()`
Annotation[] annotation = cls.getAnnotations();
// 仅获取该类上的Pro注解
Pro annotation = cls.getAnnotation(Pro.class);
// 3、获取注解上的属性方法
String className = annotation.className() // cn.xxx.annotation.Demo1
String className = annotation.methodName() // show
...

Resumir

Una anotación es algo similar a una etiqueta. Por ejemplo, si coloca una anotación de verificación en una función, significa que la función se puede verificar, luego el programa de verificación correspondiente puede ejecutar el programa correspondiente al reconocer la anotación de verificación. Si hay ningún programa de verificación, entonces la anotación en sí no tiene ningún sentido, solo como un comentario.

1. La mayoría de las veces, solo usamos anotaciones, no anotaciones personalizadas
2. ¿Para quién son principalmente las anotaciones? 1. Compilador 2. Programa de análisis
3. La anotación no es parte del programa, sino algo así como una etiqueta