En Java, la anotación se introduce en Java 5 y se utiliza para describir la meta información del código Java. Por lo general, las anotaciones no afectarán directamente la ejecución del código, aunque algunas anotaciones pueden usarse para afectar la ejecución del código.
¿Qué se puede hacer con anotaciones?
Las anotaciones en Java generalmente juegan los siguientes roles
en
Conceptos básicos de anotación
Una simple anotación de Java es similar a @Entity. Donde @ significa decirle al compilador que esta es una anotación. La entidad es el nombre de la anotación. Por lo general, en un archivo, el método de escritura es el siguiente
public @interface entity {
}
Elementos de anotación
Las anotaciones de Java pueden usar elementos para establecer algunos valores, y los elementos en las anotaciones son similares a los atributos o parámetros. Código de muestra para definir la anotación que contiene elementos
public @interface entity {
String TableName ();
}
Código de muestra utilizando anotaciones que contienen elementos
@Entity (TableName = "Vehículos")
El nombre del elemento de la anotación anterior es Tablename y el conjunto de valor es vehículos. Las anotaciones sin elementos no requieren paréntesis.
Si la anotación contiene múltiples elementos, el método de uso es el siguiente
@Entity (TableName = "Vehicles", PrimaryKey = "ID")
Si la anotación solo tiene un elemento, generalmente lo escribimos así
@InsertNew (valor = "sí")
Pero en este caso, si y solo si el nombre del elemento es valor, también podemos abreviarlo, es decir, no hay necesidad de completar el valor del nombre del elemento, el efecto es el siguiente
@InsertNew ("Sí")
Uso de anotaciones
Las anotaciones se pueden usar para modificar estos elementos en el código
Un ejemplo completo de uso es el siguiente
@EntityPublic Public Class Vehicle {@Persistent Proteged String vehicLename = null; @Getter public String getVeHeClename () {return this.vehiclename; } public void setVeHiClename (@Optional VehicLename) {this.Vehiclename = VehicLename; } Lista pública addVeHiClenametolist (nombres de la lista) {@Optional List localNames = nombres; if (localNames == null) {localNames = new ArrayList (); } localNames.Add (getVeHeClename ()); devolver los nombres locales; }}Anotaciones de Java incorporadas
Hay tres anotaciones incorporadas en Java que se utilizan para proporcionar instrucciones para el compilador. Ellos son
@Depeced
Se puede utilizar para marcar clases, métodos y propiedades.
Si ya no se usan los tres elementos anteriores, use la anotación @Depreced. Si el código usa la clase, el método o la propiedad de la anotación @Depreced, el compilador le advertirá.
@Depreced es muy simple de usar, de la siguiente manera: anotación de una clase desactivada.
@DeprecedPublic Class myComponent {}Cuando usamos la anotación @Depreced, se recomienda utilizar el símbolo Javadoc @Depreced correspondiente junto con ella y explicar por qué esta clase, método o propiedad está en desuso y cuál es la alternativa.
@Depreced/** @Depreced Esta clase está llena de errores. Use myNewComponent en su lugar.*/Clase public myComponent {}@Anular
La anotación @Override se usa para modificar el método para reescribir la clase principal. Si un método que no anula la clase principal usa esta anotación, el compilador provocará un error.
De hecho, @Overide no es necesario para anular los métodos de la clase o interfaz principal en una subclase. Sin embargo, todavía se recomienda usar esta anotación. En algunos casos, suponiendo que modifique el nombre del método de clase principal, el método de subclase que se reescribió antes ya no se reescribirá. Sin @Overide, no notará el método de esta subclase. Con esta modificación de la anotación, el compilador lo solicitará esta información.
Ejemplos de uso de anotaciones de anulación
clase pública mySuperClass {public void Doththing () {System.out.println ("Do the Thing"); }} clase pública mySubClass extiende mySuperClass {@Override public void Dothing () {System.out.println ("hazlo de manera diferente"); }}@SupessWarnings
@SupessWarnings se utiliza para suprimir el compilador de la generación de mensajes de advertencia.
Los elementos que se pueden modificar son clases, métodos, parámetros de método, atributos y variables locales
Escenario de uso: cuando un método llama a un método desaprobado o realiza una conversión de tipo insegura, el compilador generará una advertencia. Podemos agregar a este método
@SupessWarnings anotación para suprimir las advertencias de generación de compiladores.
Nota: Use la anotación de @SuppressWarnings y adopte el principio de proximidad. Por ejemplo, si un método tiene una advertencia, intentamos usar @SupplessWarnings para anotar este método, en lugar de anotar la clase donde se encuentra el método. Aunque ambos pueden suprimir al compilador de generar advertencias, cuanto más pequeño sea el alcance, mejor, porque el alcance es más grande, lo que no es propicio para descubrir información de advertencia de otros métodos bajo esta clase.
Ejemplo de uso
@SupessWarningSpublic Void MethodwithWarning () {}Crea tus propias anotaciones
En Java, podemos crear nuestras propias anotaciones, anotaciones y clases, y los archivos de interfaz se definen en nuestro propio archivo. como sigue
@Interface myAnnotation {string value (); Name de cadena (); int age (); Cadena [] Newnames ();}El código anterior define una anotación llamada MyAnnotation, que tiene 4 elementos. Nuevamente, la palabra clave @Interface se usa para decirle al compilador Java que esta es una anotación.
Si observa de cerca, encontrará que la definición de elementos de anotación es muy similar al método de interfaz. Estos elementos tienen tipos y nombres. Estos tipos pueden ser
Las siguientes son las anotaciones personalizadas de la aplicación
@Myannotation (valor = "123", name = "jakob", edad = 37, newnames = {"jenkov", "Peterson"}) clase pública MyClass {}Tenga en cuenta que necesitamos establecer valores para todos los elementos de anotación, y no puede faltar a nadie.
Valor predeterminado del elemento de anotación
Para elementos en anotaciones, podemos establecer valores predeterminados para ellos, utilizando el método
@Interface MyAnnotation {String value () predeterminado ""; Name de cadena (); int age (); Cadena [] Newnames ();}En el código anterior, establecemos el valor predeterminado del elemento de valor en una cadena vacía. Cuando lo estamos utilizando, no podemos establecer el valor, es decir, que el valor use el valor predeterminado de la cadena vacía. Usar código de muestra
@Myannotation (name = "Jakob", Age = 37, Newnames = {"Jenkov", "Peterson"}) Clase pública MyClass {}@Retención
@Retention es una anotación utilizada para modificar la anotación. Usando esta anotación, podemos hacerlo.
Controle si las anotaciones se escriben en el archivo de clase para controlar si las anotaciones en el archivo de clase son visibles en tiempo de ejecución
El control es simple, solo use una de las siguientes tres estrategias.
RetentionPolicy.Ource indica que la anotación solo existe en el código fuente, no existe. Las anotaciones comunes son @Override, @SupessWarnings.
RetentionPolicy.Class Esta es la política de retención de anotación predeterminada. Según esta estrategia, existirán anotaciones con el archivo .class, pero no se puede acceder en tiempo de ejecución. Por lo general, esta estrategia de anotación se utiliza para operar a nivel de bytecode.
Se puede acceder a RetentPolicy.Runtime en tiempo de ejecución bajo esta política. A menudo, hacemos algo en combinación con la reflexión.
Ejemplo de uso de @Retention
import java.lang.annotation.retention; import java.lang.annotation.retentionPolicy; @Retention (retentionPolicy.runtime) @Interface MyAnnotation {String value () predeterminado ";}@Objetivo
Usando la anotación @Target, podemos establecer qué elementos Java se pueden modificar mediante anotaciones personalizadas. Ejemplo simple
import java.lang.annotation.elementType; import java.lang.annotation.target; @Target ({elementType.method}) public @Interface myAnnotation {String value ();}El código anterior muestra que la anotación de MyAnnotation solo puede modificar el método.
@Target puede seleccionar los valores de los parámetros de la siguiente manera
@Heredado
Si desea una clase y su subclase contienen una anotación, puede usar @inherited para modificar esta anotación.
java.lang.annotation.inherited@inheritedpublic @interface myAnnotation {} 12@myAnnotationPublic MySuperClass {...} 1 Public Class MySubClass extiende MySuperClass {...}El significado general del código anterior es
1. Use @inherited para modificar la anotación
2. Anotación de mysuperclass usando myannotation
3. Implementar una clase que MySubClass hereda de MySuperClass
A través de los pasos anteriores, MySubClass también tiene anotación de MyAnnotation.
Estos son algunos conceptos básicos sobre las anotaciones en Java.
Lo anterior es la clasificación de anotaciones en Java. Continuaremos agregando información relevante en el futuro. ¡Gracias por su apoyo para este sitio!