Las anotaciones de Java nos permiten añadir información de metadatos en nuestro código fuente, aunque no son parte del programa en sí. Las anotaciones fueron añadidas al java desde el JDK 5. Las anotaciones no tienen un efecto directo en el funcionamiento del código que anotan (es decir, no afecta a la ejecución del programa).
En este tutorial vamos a cubrir los siguientes temas: Uso de las anotaciones, cómo aplicar las anotaciones, qué tipos de anotación predefinidos están disponibles en el Java y cómo crear anotaciones personalizadas.
¿Para qué sirven las anotaciones?
1) Instrucciones para el compilador: Hay tres anotaciones incorporadas disponibles en Java (@Deprecated, @Override & @SuppressWarnings) que pueden utilizarse para dar ciertas instrucciones al compilador. Por ejemplo, la anotación @override se utiliza para indicar al compilador que el método anotado está anulando el método. En las siguientes secciones de este artículo se habla más sobre estas anotaciones incorporadas con ejemplo.
2) Instructores en tiempo de compilación: Las anotaciones pueden proporcionar instrucciones en tiempo de compilación al compilador que pueden ser usadas posteriormente por las herramientas de construcción de software para generar código, archivos XML, etc.
3) Instrucciones en tiempo de ejecución: Podemos definir anotaciones que estén disponibles en tiempo de ejecución a las que podemos acceder mediante el uso de java reflection y que pueden utilizarse para dar instrucciones al programa en tiempo de ejecución. Discutiremos esto con la ayuda de un ejemplo, más adelante en este mismo post.
Fundamentos de las anotaciones
Una anotación siempre comienza con el símbolo @ seguido del nombre de la anotación. El símbolo @ indica al compilador que se trata de una anotación.
Por ejemplo, para @Override
Aquí el símbolo @ representa que se trata de una anotación y la anulación es el nombre de esta anotación.
¿Dónde podemos usar las anotaciones?
Las anotaciones pueden aplicarse a las clases, interfaces, métodos y campos. Por ejemplo, la siguiente anotación se aplica al método.
@Overridevoid myMethod() { //Do algo }
Lo que esta anotación está haciendo exactamente aquí se explica en la siguiente sección pero para ser breve está instruyendo al compilador que miMétodo() es un método de anulación que está anulando el método (miMétodo()) de la superclase.
Anotaciones incorporadas en Java
Java tiene tres anotaciones incorporadas:
- @Override
- Despreciada…
- @Advertencias de Supresión
1) Sobrepasar:
Mientras anulamos un método en la clase de niños, debemos usar esta anotación para marcar ese método. Esto hace que el código sea legible y evita problemas de mantenimiento, como por ejemplo: mientras se cambia la firma del método de la clase padre, se debe cambiar la firma en las clases hijas (donde se usa esta anotación), de lo contrario el compilador arrojaría un error de compilación. Esto es difícil de rastrear cuando no se ha utilizado esta anotación.
Ejemplo:
public class MyParentClass { public void justaMethod() { System.out.println("Método de la clase padre"); }}public class MyChildClass extiende MyParentClass { @Override public void justaMethod() { System.out.println("Método de la clase hijo"); }}
Creo que el ejemplo se explica por sí mismo. Para leer más sobre esta anotación, consulte este artículo: Anotación incorporada.
2) Despreciada…
@Anotación obsoleta indica que el elemento marcado (clase, método o campo) está obsoleto y ya no debe utilizarse. El compilador genera una advertencia siempre que un programa utiliza un método, clase o campo que ya ha sido marcado con la anotación @Depreciado. Cuando un elemento está obsoleto, también debe ser documentado usando la etiqueta Javadoc @obsoleto, como se muestra en el siguiente ejemplo. Anote la diferencia entre mayúsculas y minúsculas con @Depreciado y @depreciado. @deprecated se utiliza con fines de documentación.
Ejemplo:
/** * @depreciado * razón por la cual fue desaprobado */@Público desaprobado anular cualquierMétodoAquí(){ // Hacer algo}
Ahora, siempre que cualquier programa usara este método, el compilador generaría una advertencia. Para leer más sobre esta anotación, consulte este artículo: Java – @Anotación obsoleta.
3) @Advertencias de Supresión
Esta anotación instruye al compilador a ignorar advertencias específicas. Por ejemplo, en el siguiente código, estoy llamando a un método desaprobado (asumamos que el método deprecatedMethod() está marcado con la anotación @Deprecated) por lo que el compilador debería generar una advertencia, sin embargo estoy usando la anotación @@SuppressWarnings que suprimiría esa advertencia de desaprobación.
@SuppressWarnings("deprecación") anula miMétodo() { miObjeto.depreciadoMétodo();}
Creación de anotaciones personalizadas
- Las anotaciones se crean utilizando @interface, seguido del nombre de la anotación como se muestra en el siguiente ejemplo.
- Una anotación también puede tener elementos. Parecen métodos. Por ejemplo, en el siguiente código, tenemos cuatro elementos. No debemos proveer implementación para estos elementos.
- Todas las anotaciones extienden la interfaz java.lang.annotation.Annotation. Las anotaciones no pueden incluir ninguna cláusula de extensión.
importar java.lang.annotation.Documented;importar java.lang.annotation.ElementType;importar java.lang.annotation.Inherited;importar java.lang.annotation.Retention;importar java.lang.annotation.RetentionPolicy;importar java.lang.annotation.Target; @Documented@Target(ElementType.METHOD)@Inherited@Retention(RetentionPolicy.RUNTIME)public @interface MyCustomAnnotation{ int studentAge() default 18; String studentName(); String stuAddress(); String stuStream() default "CSE";}
Nota: Todos los elementos que tienen valores predeterminados establecidos al crear anotaciones pueden saltarse mientras se usa la anotación. Por ejemplo, si estoy aplicando la anotación anterior a una clase, entonces lo haría así:
@MyCustomAnnotation( studentName="Chaitanya", stuAddress="Agra, India")public class MyClass {...}
Como puedes ver, no hemos dado ningún valor a los elementos studentAge y stuStream ya que es opcional establecer los valores de estos elementos (los valores por defecto ya han sido establecidos en la definición de Anotación, pero si quieres puedes asignar un nuevo valor mientras usas la anotación de la misma manera que lo hicimos para otros elementos). Sin embargo, tenemos que proporcionar los valores de otros elementos (los elementos que no tienen valores predeterminados establecidos) mientras usamos la anotación.
Nota: también podemos tener elementos de matriz en una anotación. Así es como podemos usarlos:
Definición de la anotación:
@interface MyCustomAnnotation { int count(); String[] books();}
Uso:
@MyCustomAnnotation( count=3, books={"C++", "Java"})public class MyClass {}
Volvamos al tema otra vez: En el ejemplo de la anotación personalizada hemos utilizado estas cuatro anotaciones: @Documentado, @Objetivo, @Heredado y @Retención. Vamos a discutirlo en detalle.
@Documentado
La anotación @Documentada indica que los elementos que utilizan esta anotación deben ser documentados por JavaDoc. Por ejemplo:
java.lang.annotation.Documented@Documentedpublic @interface MyCustomAnnotation { //Annotation body}
@MyCustomAnnotationpublic class MyClass { //Class body}
Mientras se genera el javadoc para la clase MyClass, la anotación @MyCustomAnnotation estaría incluida en eso.
@Target
Especifica dónde podemos usar la anotación. Por ejemplo: En el siguiente código, hemos definido el tipo de objetivo como MÉTODO, lo que significa que la siguiente anotación sólo puede ser utilizada en los métodos.
importar java.lang.anotación.ElementType;importar java.lang.anotación.Target;@Target({ElementType.METHOD})public @interface MyCustomAnnotation {}
clase pública MyClass { @MyCustomAnnotation public void myMethod() { //Doing something }}
Nota: 1) Si no se define ningún tipo de objetivo, eso significa que la anotación puede aplicarse a cualquier elemento.
2) Aparte de ElementType.METHOD, una anotación puede tener los siguientes valores posibles de Target.
ElementType.METHOD
Paquete Elemental.
Tipo de elemento. PARÁMETRO
ElementType.TIPO
ElementType.ANNOTATION_TYPE
CONSTRUCTOR DE TIPO ELEMENTAL
ElementType.LOCAL_VARIABLE
CAMPO DE TIPO DE ELEMENTO
Herencia
La anotación @Heredado señala que una anotación personalizada utilizada en una clase debe ser heredada por todas sus subclases. Por ejemplo:
java.lang.annotation.Inherited@Inheritedpublic @interface MyCustomAnnotation {}
@MyCustomAnnotationpublic class MyParentClass { ... }
La clase pública MyChildClass extiende la clase de MyParentClass { ... }
Aquí la clase MyParentClass está usando la anotación @MyCustomAnnotation que está marcada con la anotación @heredada. Significa que la subclase MyChildClass hereda la @MyCustomAnnotation.
@Retención
Indica cuánto tiempo se deben conservar las anotaciones con el tipo anotado.
importar java.lang.anotación.Retención;importar java.lang.anotación.Política de Retención;@Retención(Política de Retención.RUNTIME)@interfaz MiAnotaciónAduana { }
Aquí hemos usado la Política de Retención. RUNTIME. Hay otras dos opciones también. Veamos qué significan:
Política de Retención. RUNTIME: La anotación debería estar disponible en tiempo de ejecución, para su inspección a través de la reflexión de java.
RetentionPolicy.CLASS: La anotación estaría en el archivo .class pero no estaría disponible en tiempo de ejecución.
RetentionPolicy.SOURCE: La anotación estaría disponible en el código fuente del programa, no estaría en el archivo .class ni estaría disponible en tiempo de ejecución.
Eso es todo para este tema «Anotación de Java». Si tiene alguna pregunta, siéntase libre de dejar una línea abajo.
