anotación
1. ¿Qué es la anotación? (Anotación o comentarios)
Anotación, la traducción precisa debe ser: anotación. Es completamente diferente de los comentarios.
La anotación es una característica introducida por JDK5.0 y versiones posteriores. Está al mismo nivel que las clases, las interfaces y las enumeraciones y puede convertirse en un tipo de Java.
La sintaxis comienza con @,
Los comentarios son una memorización o descripciones rápidas hechas por los programadores de las clases de código fuente, métodos, propiedades, etc. (como para lo que se utiliza este método) y son para que las personas lo vean.
La anotación es la parte que el compilador Java puede entender y es para que el compilador la vea.
Demos un ejemplo simple para ver el uso y la función de las anotaciones.
@Override es una anotación incorporada común Java. Su función es verificar si los métodos definidos en la subclase son correctos al compilar el código.
anotación de paquete; Public Abstract Class Animal {public abstract void eat (); } anotación del paquete; Public Class Cat extiende Animal {@Override public void Eat (String Food) {}} Aquí, en el gato de subclase, el método EAT se anota como un método que sobrescribe la clase principal, pero tiene un parámetro más que el método de la clase principal.
Si está editando en Eclipse, habrá un aviso de la Cruz Roja. (No se aprobará la compilación de código).
Si elimina la anotación @Override, no hay problema con la compilación, pero el método EAT en CAT es un nuevo método de esta clase, no heredado de la clase principal.
2. Annotaciones incorporadas comunes de Java
Incluyendo @Override, ¿qué otras anotaciones incorporadas comunes de Java?
1. @Depreced
No se recomienda la anotación y se puede utilizar en métodos y clases.
Básicamente, este método y clase se abandonan y no se recomiendan por algunas razones, como la actualización o el rendimiento, pero deben conservarse por compatibilidad u otras razones.
Así que pon esta anotación en ella.
Hay muchos ejemplos de este tipo en la propia API de Java. Si pone esta anotación en el método, verá qué nuevo método alternativo es.
Al escribir código en Eclipse, el método que agrega esta anotación agregará strikethroughs tanto a la declaración como a la llamada.
2.@anular
3.@supresswarnings
Ignorar advertencias.
Si su código tiene algunas advertencias en la transformación u otras partes, pero desea ignorar estas advertencias, puede usar esta anotación.
1) ADVERTENCIA Cuando la deprecación usa una clase o método que no se favorece
2) Advertencia sin control cuando se realiza una conversión sin control
3) Las advertencias de caída aparecen cuando la operación de descanso no se agrega después de que se usa el caso, lo que hace que el programa continúe ejecutando otras declaraciones de caso
4) Advertencia de ruta al establecer una ruta de archivo de clase incorrecta o archivo de origen
5) ADVERTENCIA ENERIA Cuando la definición en serie VersionUid falta en la clase serializable
6) Advertencia de Fianally si alguna cláusula finalmente no se puede completar normalmente
7) Todas las advertencias sobre todas las situaciones anteriores
3. Anotaciones personalizadas
Además de las anotaciones incorporadas proporcionadas por el propio Java, Java también proporciona la función de personalizar las anotaciones personalizadas.
La forma de definir anotaciones es usar anotaciones para definir anotaciones. Las anotaciones utilizadas para definir anotaciones se llaman meta anotaciones.
Las meta anotaciones principales son las siguientes: @Target; @Retención; @Documented; @Heredado
1. @Target indica dónde se usa la anotación y puede usarse en clases, métodos o atributos. Los posibles parámetros de Elemenettype incluyen:
Elemenettype.Constructor Constructor Declaration
Elemenettype.field Declaración de dominio (incluidas las instancias de enum)
Elemenettype.local_variable Declaración de variable local
Elemenettype. Declaración del método del método
Elemenettype. Declaración del paquete de packaje
Elemenettype.Parameter Parameter Declaration
Elemenettype. Clase de tipo, interfaz (incluido el tipo de anotación) o la declaración de enum
2. @Retention indica en qué nivel guardar la información de anotación. Los parámetros opcionales de retención incluyen:
RetentionPolicy. La anotación de fuentes será descartada por el compilador
La anotación de RetentPolicy.Class está disponible en el archivo de clase, pero la VM lo descartará.
RetententPolicy.Runtime VM también retendrá comentarios durante el tiempo de ejecución, por lo que la información de anotación se puede leer a través del mecanismo de reflexión.
3. @Documented, si se debe incluir esta anotación al generar DOC, incluya esta anotación en Javadoc
4. @Inherited
Deje que las subclases hereden las anotaciones en la clase principal, consulte algunos ejemplos de definición simples:
anotación de paquete; import java.lang.annotation.documented; import java.lang.annotation.ElementType; import java.lang.annotation.inherited; import java.lang.annotation.retention; import java.lang.annotation.retentionPolicy; import java.lang.annotation.target; @Target (elementType.method) public @Interface MyAnnotation {String value (); } @Retention (retentionPolicy.source) @Interface myAnnotation1 {} @retention (retentionPolicy.class) @Interface MyAnnotation2 {} @Retention (retentionPolicy.runtime) @Interface MyAnnotation3 {} @Documed @Interface MyAnnotation4 {} @inherited @interface MyAnnotation3 {} @Documed @Interface @interface MyAnnotation4 {} @inherited @interface MyAnnotation3 {} @Documed @Interface MyAnnotation4 {} @inherited @Interface MyAnnotation4. Use ejemplos:
anotación de paquete; import java.lang.annotation.annotation; @MyAnnotation3 public class testAnnotation {public static void main (string [] args) {// tODO Auto Generated Annotation anotación = testAnnotation.class.getAnnotation (myAnnotation3.class); System.out.println (annotation.toString ()); }} Imprima el resultado: @annotation.myannotation3 ()
Si MyAnnotation1 y MyAnnotation2 se reemplazan en el ejemplo anterior, el valor de la anotación obtenida es vacía, que es la diferencia entre la capacidad de retención.
V. El papel de la anotación
En este punto, podemos resumir el papel de la anotación.
Los conceptos básicos se pueden dividir aproximadamente en tres categorías:
1. Escribe un documento
2. Análisis de código
3. Comprobación de compilación Sin embargo, los marcos de código abierto le dan más funciones, como:
Hibernate, configuración de anotación,
@Column ("aa") cadena privada xx; Esto es similar a la configuración XML, que simplifica la configuración en el programa y mueve una parte de los metadatos del archivo XML al código en sí, y la administra y mantiene en un solo lugar.
¿Cómo se implementa internamente? - Mecanismo de reflexión de Java, similar al ejemplo anterior.
Comentario
Aunque las anotaciones y los comentarios son solo una palabra diferente, el uso es muy diferente.
La misma oración es verdadera, las anotaciones son para que el compilador lo vea, y las anotaciones son para que las personas lo vean.
Basado en esto, para un método:
1. Simplemente describa la función de este método claramente, entrada y salida. Puede agregar más información, como autores y versiones.
2. Simplemente haga estas dos cosas con un hermoso arreglo de comentarios. Por ejemplo:
/********************************************************************************************************************* * NAME: usage * DESCRIPTION: XXX * ARGUMENTS: N/A * RETURN: * AUTHOR: oscar999 * VERSION: V0.1 ************************************************************************************
Parece que esta es una buena nota ^^.
Pero para el idioma Java, los comentarios reciben más funciones. Es decir, puede usar la función Javadoc para exportar comentarios en el código al archivo HTML.
Si su código es código con alta en comparación, este documento es un documento de referencia de API, similar a la API Java.
Por lo tanto, para generar dicho documento, debe seguir algunas especificaciones de anotación definidas por Java para producir un documento estandarizado.
1. Comentarios estándar sobre métodos de clase Java
Comencemos con los comentarios sobre el método de clase.
/*** Lea una línea de texto. Se considera que una línea es terminada por cualquier * de un alimento de línea ('/n'), un retorno de carro ('/r') o un retorno de carro * seguido inmediatamente por una línea de línea. * * @param ignorelf1 Si es verdadero, el siguiente '/n' se omitirá <pre code_snippet_id = "74911" fnippet_file_name = "blog_20131120_2_8365599" name = "código"> * @param Cualquier caracteres de terminación de línea, o nulo si se ha alcanzado el final de la * transmisión * * * @see java.io.linenumberreader#readline () * * @Exception ioexception si ocurre un error de I/o */ (No preste atención al significado de los comentarios anteriores, solo concéntrese en el estilo de su definición)
1. Primero mire a la parte superior "Lea una línea de texto. Una línea ...". Este párrafo es una descripción de este método.
La parte antes del primer período, que es "leer una línea de texto". aparecerá en "Resumen del método"
2. @Param define los parámetros de entrada del método, que (múltiples se puede agregar) aparece en "Detalles del método". (El parámetro y la descripción del parámetro están separados por espacios y se convierten en - en el documento generado)
3. @Return Descripción del valor de retorno
4. @See Descripción de referencia
5. La descripción de @Exception lanzada por la excepción es hermosa. Se pueden mostrar diferentes tipos de etiquetas en una línea, como @param y @return vacía directamente una línea.
2. Comentarios estándar de clase Java
El formato de anotaciones de clase y anotaciones de métodos es básicamente el mismo. ¿Cuál es la diferencia?
1. La colocación es diferente. Las anotaciones de clase se colocan por encima de la definición de clase, y las anotaciones del método se colocan por encima de la definición del método.
2. La comparación de anotaciones de clase usa etiquetas como @version @author @since.
Mira la plantilla
/** Bumarcará la entrada del archivo especificado. Sin almacenamiento en búfer, cada * invocación de Read () o Readline () podría hacer que se lean bytes del archivo *, convertido en caracteres y luego devuelto, lo que puede ser muy * inherente. * * Test Descripción * * <p> Los programas que usan DataInputStreams para la entrada textual se pueden localizar * reemplazando cada DataAnputStream con un BufferedReader apropiado. * * @see FileReader * @see inputstreamreader * * @version 0.1, 20/20/13 * @author Oscar999 * @since jdk1.5 */
Los efectos que se muestran en DOC son:
Del mismo modo, la primera oración de la descripción aparece en el "Clasificar".
Los detalles de la clase se muestran de la siguiente manera:
Vale la pena señalar que el uso de <p> en la descripción. Si <p> no se agrega, sin importar si hay una nueva línea en el código Java, el documento generado no será nuevo. Si se agrega <p>, aparece una nueva línea en DOC.
3. Suplemento
Para agregar, el método para generar javadoc:
1. Método de línea con nombre: Javadoc + Parámetros
2. Use el IDE Eclipse para exportar si está en el IDE de Eclipse, haga clic con el botón derecho en el archivo o proyecto fuente, seleccione Exportar --->
Java -> Javadoc se puede generar.