Descripción general
Java introdujo una anotación en la versión 1.5, también conocida como anotación Java. La anotación es un tipo de metadatos de sintaxis que se pueden usar directamente en el código fuente, y se pueden anotar clases/métodos/variables/parámetros/nombres de paquetes, etc. A diferencia de las etiquetas Javadoc, el compilador puede retener el código de anotación al generar el archivo de clase. Al mismo tiempo, para usar anotaciones durante el proceso de tiempo de ejecución, la máquina virtual Java mantiene la anotación, de modo que la información relevante sobre la anotación se puede obtener a través de la reflexión.
Anotaciones incorporadas
De hecho, a menudo encontramos anotaciones, como @Override, @depreced, etc. Todas estas son anotaciones incorporadas en JDK. Primero echemos un vistazo a cuáles son las principales anotaciones incorporadas en Java.
• Anotaciones que actúan sobre el código Java
◦@anular verifica si un método es un método de reescritura. Si este método no se encuentra en la clase principal o la interfaz implementada, se producirá un error de compilación.
◦@marcas desactivadas que se descarta un método o clase. Si se utiliza la clase o el método, el proceso de compilación lo alertará.
◦@supresswarnings notifica al compilador que ignore las advertencias sobre los parámetros anotados
◦@SafeVarargs ignora las advertencias sobre métodos de llamadas o constructores que contienen parámetros genéricos, 1.7 ha agregado anotaciones
◦@funcionalInterface indica que una interfaz declarada se utilizará como una interfaz funcional. 1.8 ha agregado anotación
• Las anotaciones realizadas en otras anotaciones se llaman meta anotaciones (meta anotación)
◦@retención especifica cuándo se usa la anotación anotada (es decir, cuándo se retendrá la anotación)
■ Retención solo en código fuente y descartado durante la compilación (retención Policy.Runtime)
■ Las anotaciones se guardan en el archivo de clase durante la compilación, y se ignoran cuando se carga el archivo de clase (retenciónPolicy.class)
■ Las anotaciones se leen cuando se carga el archivo de clase, es decir, las anotaciones están disponibles durante la operación. Las anotaciones se pueden obtener a través de la reflexión (retención Policy.Runtime)
◦@documentado indica que al generar Javadoc, las anotaciones anotadas se escribirán en el documento Javadoc.
◦@El objetivo especifica el alcance de la anotación anotada ■ ElementType.Type: Se usa para describir una clase, interfaz (incluido el tipo de anotación) o Declaración de enum ■ elementtype.field: se usa para describir el dominio ■ elementtype.method: se usa para describir el método ■ elementtype.parameter: Usado para describir los parámetros ■ element ■ elementphe.constructor. constructor ■ elementtype.local_variable: se usa para describir la variable local ■ elementtype.annotation_type: se usa para describir la anotación ■ elementtype.package: se usa para describir el paquete
◦ @Herherited indica que la anotación se hereda, es decir, si un tipo de anotación modificado por @inherited se usa para una clase, la anotación también actuará en la subclase de la clase modificada.
◦@repetibles indica que la anotación anotada se puede aplicar al mismo objeto varias veces. 1.9 ha agregado anotación
Anotaciones personalizadas
He mencionado muchas anotaciones anteriores, y todos se centran en meta anotaciones. Cuando personalizamos las anotaciones, generalmente usamos meta anotaciones para ayudarnos. El formato de anotación personalizada es público @Interface Annotation Nombre {Cuerpo de definición}. Al usar @Interface Custom Annotation, la interfaz java.lang.annotation.annotation se hereda automáticamente. Al personalizar las anotaciones, no se pueden heredar otras anotaciones o interfaces. El método declarado en la anotación es en realidad un parámetro de comentarios. El nombre del método es el nombre del parámetro, y el tipo de valor de retorno es el tipo de parámetro. El valor predeterminado del parámetro se puede declarar por defecto.
Las anotaciones personalizadas son simples, use @Interface para definir una anotación, de la siguiente manera.
@Retention (retenciónPolicy.Runtime) @Target (elementType.type) @DocumentedPublic @Interface classInfo {String autor () predeterminado "wang"; Date de cadena (); Comentarios de cadena ();} Una anotación personalizada llamada classInfo. Según @Retention, puede saber que esta anotación siempre existirá, es decir, esta anotación sigue siendo válida cuando el programa se está ejecutando; @Target (ElementType.Type) significa que la anotación de classInfo actúa en la clase, la interfaz o la declaración de enum; @Documented
Instrucciones La información de classInfo se puede escribir en documentos Javadoc.
Echemos un vistazo a algunos parámetros de anotación en anotaciones personalizadas. Hay tres parámetros de anotación. Los parámetros de anotación se pueden establecer de forma predeterminada, como el parámetro de anotación del autor, el valor predeterminado es Wang y los otros dos parámetros no tienen valores predeterminados.
Veamos otra anotación personalizada.
@Retention (retenciónPolicy.Runtime) @Target (elementType.method) public @Interface MethodInfo {String Descripción () predeterminado "Sin descripción"; String date ();}Este método de anotación personalizado actúa sobre el método, y esta anotación también existirá cuando el programa se esté ejecutando; Hay dos parámetros de anotación en él.
Para anotar la definición de parámetros (definición del método), solo puede usar dos modificadores de derechos de acceso público o predeterminado. Los tipos de parámetros admiten los siguientes tipos.
• Ocho tipos de datos básicos (byte, int, short, largo, flotante, doble, char, booleano)
• Tipo de cadena
• Tipo de clase
• Tipo de enum
• Tipo de anotación
• Matrices de todos los tipos anteriores
Uso de anotaciones
Además de las dos anotaciones anteriores, se ha agregado una anotación con alcance de campo.
@Retention (retenciónPolicy.Runtime) @Target (elementType.field) public @Interface FieldInfo {String type (); Nombre de cadena ();}Si los valores predeterminados no se declaran en anotaciones personalizadas, a estos parámetros se les debe asignar valores al usar anotaciones personalizadas, de lo contrario, el compilador informará un error.
Eche un vistazo al código utilizado por la anotación:
@Classinfo (autor = "wang", date = "2016/9/13", comentarios = "Demo de anotación") Public Class AnnotationDemo {@FieldInfo (type = "public", name = "FirstField") public int FirstField; @FieldInfo (type = "privado", name = "Secondfield") String private Secondfield; @Methodinfo (description = "método en anotationDemo", name = "firstMethod") public void FirstMethod (Value de cadena) {System.out.printf ("Primer método involucrado"); } @Methodinfo (description = "Método en AnnotationDemo", name = "Secondmethod") private void SecondMethod () {System.out.printf ("Primer método involucrado"); }}Obtener información de anotación
Para obtener información de anotación, primero debemos asegurarnos de que la anotación existirá durante la ejecución del programa. Por lo tanto, generalmente agregamos @Retention (retenciónPolicy.Runtime) meta anotación a anotaciones personalizadas. De esta manera, durante la ejecución del programa, podemos obtener información de anotación a través de la reflexión. Para obtener instrucciones sobre la reflexión, puede ver este artículo.
Public Class AnnotationTest {public static void main (String [] args) {resolveclassAnnotationInfo (annotationDemo.class); ResolveFieldAnnotationInfo (anotationDemo.class); resolVemethodannotationInfo (anotationdemo.class); } private static void resolveClassAnnotationInfo (class <?> clz) {// Determine si esta clase tiene anotación classInfo if (clz.isannotationPresent (classinfo.class)) {classInfo classInfo = (classInfo) clz.getannotation (classinfo.class); System.out.println (classinfo.author () + "" + classinfo.comments () + "" + classinfo.date ()); }} private static void resolveFieldAnnotationInfo (class <?> clz) {campo [] fields = clz.getDeclaredfields (); for (campo campo: campos) {if (field.isannotationPresent (fieldInfo.class)) {fieldInfo fieldInfo = (fieldInfo) field.getAnnotation (fieldInfo.class); System.out.println (fieldInfo.Type () + "" + fieldInfo.name ()); }}} private static void resolVemethodannotationInfo (class <?> clz) {método [] métodos = clz.getDeclaredMethods (); para (método método: métodos) {if (método.IsannotationPresent (MethodInfo.class)) {MethodInfo MethodInfo = (MethodInfo) Method.getAnnotation (MethodInfo.class); System.out.println (MethodInfo.Name () + "" + MethodInfo.Description ()); }}}}Reflexión para obtener campo/método en la clase, etc., y obtener anotaciones relevantes a través de getAnnotation () o getAnnotations (). Puede obtener información específica obteniendo las anotaciones específicas.
La salida del resultado de ejecución es la siguiente:
Figura 1 Diagrama de resultados de operación
Resumir
Para los principiantes de Java e incluso los desarrolladores de Java con cierta experiencia, pueden tener menos exposición a las anotaciones de Java. En realidad, las anotaciones rara vez se usan, pero a menudo las verán en el código. Este artículo es una simple introducción a las anotaciones, y al menos a nivel de código, es sin estrés de leer.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.