¿Qué es la anotación?
La anotación (anotación) es una forma y método proporcionado por Java para asociar cualquier información y metadatos (metadatos) con elementos en el metaprograma. La anotación (anotación) es una interfaz. El programa puede obtener el objeto de anotación del elemento de programa especificado a través de la reflexión y luego obtener los metadatos en la anotación a través del objeto de anotación.
La anotación (anotación) se introduce en JDK5.0 y versiones posteriores. Se puede utilizar para crear documentación, realizar un seguimiento de las dependencias en su código e incluso realizar comprobaciones básicas en tiempo de compilación. De alguna manera, las anotaciones se utilizan como modificadores y se aplican a la declaración de paquetes, tipos, constructores, métodos, variables miembro, parámetros y variables locales. Esta información se almacena en el par de estructuras de anotación "nombre = valor".
Los miembros de una anotación se declaran como métodos sin parámetros en el tipo de anotación. Su nombre de método y valor de retorno definen el nombre y el tipo del miembro. Aquí hay una sintaxis predeterminada específica: se permite declarar el valor predeterminado de cualquier miembro de la anotación: una anotación puede usar un par nombre=valor como el valor de un miembro de la anotación que no define un valor predeterminado. El par =valor también se puede utilizar para anular el valor predeterminado de otros miembros. Esto es algo similar a las características de herencia de las clases. El constructor de la clase principal se puede utilizar como constructor predeterminado de la subclase, pero la subclase también puede anularlo.
La anotación se puede utilizar para asociar cualquier información con un elemento del programa (clase, método, variable miembro, etc.). Cabe señalar que aquí existe una regla básica: la anotación no puede afectar la ejecución del código del programa, ya sea que se agregue o elimine una anotación, el código se ejecutará de manera consistente. Además, aunque se accede a algunas anotaciones en tiempo de ejecución a través de los métodos API de reflexión de Java, el intérprete del lenguaje Java ignora estas anotaciones mientras trabaja. Es precisamente porque la máquina virtual Java ignora la anotación que el tipo de anotación "no funciona" en el código solo se puede acceder y procesar la información del tipo de anotación a través de algunas herramientas de soporte; Este artículo cubrirá los tipos de anotación y metaanotación estándar. La herramienta que acompaña a estos tipos de anotación es el compilador de Java (que, por supuesto, los maneja de alguna manera especial).
-------------------------------------------------- ----------------------------------
¿Qué son los metadatos (metadatos)?
Metadatos se traduce de la palabra metadatos, que significa "datos sobre datos".
Los metadatos tienen muchas funciones. Por ejemplo, es posible que haya utilizado comentarios de Javadoc para generar documentación automáticamente. Este es un tipo de función de metadatos. En general, los metadatos se pueden utilizar para crear documentación, rastrear dependencias de código, realizar comprobaciones de formato en tiempo de compilación y reemplazar archivos de configuración existentes. Si queremos clasificar el papel de los metadatos, actualmente no existe una definición clara, pero podemos dividirlos aproximadamente en tres categorías según su papel:
1. Escribir documentos: generar documentos a través de los metadatos identificados en el código 2. Análisis de código: analizar el código a través de los metadatos identificados en el código 3. Verificación de compilación: utilizando los metadatos identificados en el código, el compilador puede lograr una compilación básica Verifique que Los metadatos en Java existen en el código Java en forma de etiquetas. La existencia de etiquetas de metadatos no afecta la compilación y ejecución del código del programa. Solo se utiliza para generar otros archivos o para conocer el código que se ejecuta en tiempo de ejecución. información.
En resumen:
Primero, los metadatos existen en el código Java en forma de etiquetas.
En segundo lugar, la información descrita por los metadatos tiene seguridad de tipos, es decir, los campos dentro de los metadatos tienen tipos claros.
En tercer lugar, los metadatos requieren un procesamiento adicional por parte de herramientas distintas al compilador utilizado para generar otros componentes del programa.
Cuarto, los metadatos solo pueden existir en el nivel del código fuente de Java o pueden existir dentro del archivo de clase compilado.
-------------------------------------------------- ----------------------------------
Anotación y tipos de anotación:
Anotación:
La anotación utiliza la nueva sintaxis incorporada en java5.0 y su comportamiento es muy similar a modificadores como público y final. Cada anotación tiene un nombre y el número de miembros >=0. Cada miembro de una anotación tiene un nombre y un valor llamado par nombre=valor (como un javabean), y nombre=valor carga la información de la anotación.
Tipo de anotación:
El tipo de anotación define el nombre, el tipo y el valor predeterminado del miembro de la anotación. Se puede decir que un tipo de anotación es una interfaz Java especial. Sus variables miembro están restringidas y se requiere una nueva sintaxis al declarar un tipo de anotación. Cuando accedemos a Anotación a través de la API de reflexión de Java, el valor de retorno será un objeto que implementa la interfaz de tipo de anotación. Al acceder a este objeto, podemos acceder fácilmente a sus miembros de Anotación. Los siguientes capítulos mencionarán los tres tipos de anotaciones estándar incluidos en el paquete java.lang de java5.0.
-------------------------------------------------- ----------------------------------
Categorías de anotaciones:
Según la cantidad de parámetros de anotación, podemos dividir las anotaciones en tres categorías:
1. Anotación de marca: un tipo de anotación sin definición de miembro se denomina anotación de marca. Este tipo de Anotación sólo utiliza su propia presencia o ausencia para proporcionarnos información. Por ejemplo, la siguiente anotación del sistema @Override;
2. Anotación de valor único 3. Anotación completa
Según el uso y propósito de las anotaciones, podemos dividirlas en tres categorías:
1. Anotaciones del sistema integrado JDK 2. Metanotaciones 3. Anotaciones personalizadas
-------------------------------------------------- ----------------------------------
Anotaciones estándar integradas en el sistema:
La sintaxis de las anotaciones es relativamente simple, excepto por el uso del símbolo @, que es básicamente consistente con la sintaxis inherente de Java. Hay tres anotaciones estándar integradas en JavaSE, que se definen en java.lang:
@Override: se utiliza para modificar este método para anular el método de la clase principal;
@Deprecated: utilizado para modificar métodos obsoletos;
@SuppressWarnings: se utiliza para notificar al compilador de Java que suprima advertencias de compilación específicas.
Echemos un vistazo a las funciones y escenarios de uso de las tres anotaciones estándar integradas.
-------------------------------------------------- ----------------------------------
@Override, restringe la anulación de métodos de clase principal:
@Override es un tipo de anotación de marcador que se utiliza para anotar métodos. Muestra que el método anotado sobrecarga el método de la clase principal y desempeña el papel de afirmación. Si utilizamos este tipo de anotación en un método que no anula el método de la clase principal, el compilador de Java le advertirá con un error de compilación. Esta anotación a menudo entra en juego cuando intentamos anular un método de clase principal pero escribimos el nombre de método incorrecto. El uso es extremadamente simple: cuando use esta anotación, simplemente agregue @Override delante del método modificado. El siguiente código es un ejemplo del uso de @Override para modificar el método displayName() de un intento de anular la clase principal, pero hay errores ortográficos:
nombre de visualización vacío público(){
System.out.println("El nombre de la fruta es: *****");
}
}
clase Naranja extiende Fruta {
@Anular
nombre de visualización vacío público(){
System.out.println("El nombre de la fruta es: naranja");
}
}
clase Apple extiende Fruta {
@Anular
nombre de visualización vacío público(){
System.out.println("El nombre de la fruta es: Manzana");
}
}
@Deprecated, la etiqueta está en desuso:
De manera similar, Obsoleto también es una anotación de marcado. Cuando un tipo o miembro de tipo está decorado con @Deprecated, el compilador desaconsejará el uso de este elemento de programa anotado. Y este tipo de modificación tiene un cierto grado de "continuidad": si usamos este tipo o miembro obsoleto en el código mediante herencia o sobrescritura, aunque el tipo o miembro heredado o anulado no se declara @Deprecated, el compilador aún tiene que advertir tú.
Vale la pena señalar que existe una diferencia entre el tipo de anotación @Deprecated y la etiqueta @deprecated en javadoc: la primera es reconocida por el compilador de Java, mientras que la segunda es reconocida por la herramienta javadoc y utilizada para generar documentación (incluyendo por qué programar). miembros están obsoletos, y su descripción de cómo se debe prohibir o reemplazar).
En Java 5.0, el compilador de Java todavía busca las etiquetas Javadoc @deprecated y las utiliza para generar mensajes de advertencia como lo hacía en versiones anteriores. Pero esta situación cambiará en versiones posteriores y deberíamos comenzar a usar @Deprecated ahora para decorar métodos obsoletos en lugar de la etiqueta javadoc @deprecated.
En el siguiente programa, la anotación @Deprecated se usa para marcar el método como caducado. Al mismo tiempo, la etiqueta @deprecated se usa en la anotación del método para marcar el método como caducado.
/**
* @deprecated Este método ha caducado y no se recomienda.
*/
@Obsoleto
showTaste público vacío(){
System.out.println("El sabor de las manzanas con sabor a fruta es: crujiente y dulce");
}
showTaste público vacío (int typeId) {
si(tipoId==1){
System.out.println("El sabor de la fruta manzana es: agrio");
}
de lo contrario si(tipoId==2){
System.out.println("El sabor de las manzanas con sabor a fruta es: dulce");
}
demás{
System.out.println("El sabor de las manzanas con sabor a fruta es: crujiente y dulce");
}
}
}
clase pública FruitRun {
/**
* argumentos @param
*/
público estático vacío principal (String [] argumentos) {
manzana manzana=nueva manzana();
apple.displayName();
AppleService appleService=nuevo AppleService();
appleService.showTaste();
appleService.showTaste(0);
appleService.showTaste(2);
}
}
-------------------------------------------------- ----------------------------------
SuppressWarnings, suprime las advertencias del compilador:
@SuppressWarnings se utiliza para desactivar selectivamente las advertencias del compilador para clases, métodos, variables miembro e inicialización de variables. En java5.0, el compilador javac proporcionado por sun nos proporciona la opción -Xlint para permitir que el compilador advierta contra código de programa legal. Esta advertencia representa un error del programa hasta cierto punto. Por ejemplo, cuando usamos una clase de colección genérica sin proporcionar su tipo, el compilador generará una advertencia de "advertencia no marcada". Normalmente, cuando esto sucede, necesitamos encontrar el código que provocó la advertencia. Si realmente representa un error, debemos corregirlo. Por ejemplo, si el mensaje de advertencia indica que la declaración de cambio en nuestro código no cubre todos los casos posibles, entonces debemos agregar un caso predeterminado para evitar esta advertencia.
A veces no podemos evitar esta advertencia. Por ejemplo, no podemos evitar esta advertencia no marcada cuando usamos una clase de colección genérica que debe interactuar con código antiguo no genérico. @SuppressWarning será útil en este momento. Agregue la modificación @SuppressWarnings antes del método llamado para indicarle al compilador que deje de advertir sobre este método.
SuppressWarning no es una anotación de marcado. Tiene un miembro de tipo String[], el valor de este miembro es el nombre de advertencia prohibido. Para el compilador javac, los nombres de advertencia que son válidos para la opción -Xlint también lo son para @SuppressWarings y el compilador ignora los nombres de advertencia no reconocidos.
La sintaxis de la anotación permite que el nombre de la anotación vaya seguido de paréntesis. Entre paréntesis se encuentran pares nombre=valor separados por comas que se utilizan para asignar valores a los miembros de la anotación. Los ejemplos son los siguientes:
@SuppressWarnings(valor={ "rawtypes", "sin marcar" })
Lista pública estática<Fruta> getFruitList(){
Lista<Fruta> ListaFruta=new ArrayList();
devolver lista de frutas;
}
@SuppressWarnings({ "rawtypes", "sin marcar" })
Lista pública estática<Fruta> getFruit(){
Lista<Fruta> ListaFruta=new ArrayList();
devolver lista de frutas;
}
@SuppressWarnings("no utilizado")
principal vacío estático público (String [] argumentos) {
Lista<Cadena> strList=new ArrayList<Cadena>();
}
}
Una breve descripción de los valores de parámetros comunes anotados por SuppressWarnings:
1.deprecation: advertencia cuando se utilizan clases o métodos obsoletos;
2. sin marcar: advertencia cuando se realiza una conversión sin marcar, por ejemplo, cuando se usa una colección, los genéricos no se usan para especificar el tipo de colección guardada;
3.fallthrough: Advertencia cuando el bloque del programa Switch conduce directamente a la siguiente situación sin Break;
4.ruta: Advertencia cuando no existen rutas en la ruta de clase, ruta del archivo fuente, etc.;
5.serial: Advertencia cuando falta la definición serialVersionUID en una clase serializable;
6.finalmente: Advertencia cuando alguna cláusula final no se puede completar normalmente;
7.all: Advertencia sobre todas las situaciones anteriores.