Anotaciones de Java nos permiten agregar información de metadatos en nuestro código fuente, aunque no son parte del programa en sí. Las anotaciones fueron agregadas a java por JDK 5. La anotación no tiene un efecto directo sobre el funcionamiento del código que anotan (es decir, no afecta la ejecución del programa).
En este tutorial cubriremos los siguientes temas: Uso de anotaciones, cómo aplicar anotaciones, qué tipos de anotaciones predefinidas están disponibles en Java y cómo crear anotaciones personalizadas.
¿Para qué sirven las anotaciones?
1) Instrucciones para el compilador: Hay tres anotaciones integradas en Java (@Deprecated, @Override Y @SuppressWarnings) que se puede utilizar 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. Más información sobre estas anotaciones complementadas con ejemplos se analiza en secciones posteriores de este artículo.
2) Instructores que se están compilando: Las anotaciones pueden proporcionar instrucciones en tiempo de compilación al compilador que pueden ser utilizadas por las herramientas de compilación de software para generar código, archivos XML, etc.
3) Instrucciones de tiempo de ejecución: Podemos definir anotaciones disponibles en tiempo de ejecución a las que podemos acceder usando reflejo de java y se puede utilizar para dar instrucciones al programa en tiempo de ejecución. Discutiremos esto con la ayuda de un ejemplo, más adelante en esta misma publicación.
Conceptos básicos de las anotaciones
Una anotación siempre comienza con el símbolo @ seguido del nombre de la anotación. El símbolo @ le dice al compilador que se trata de una anotación.
Por ejemplo @Override
Aquí, el símbolo @ representa que se trata de una anotación y Override es el nombre de esta anotación.
¿Dónde podemos usar las anotaciones?
Las anotaciones se pueden aplicar a clases, interfaces, métodos y campos. Por ejemplo, la siguiente anotación se aplica al método.
@Override
void myMethod() {
//Do something
}
Exactamente lo que hace esta anotación aquí se explica en la siguiente sección, pero para ser breve, se trata de instruir al compilador que myMethod() es un método que anula el método de la superclase (myMethod ()).
Anotaciones integradas en Java
Java tiene tres anotaciones integradas:
- @Paso superior
- @ Obsoleto
- @SuppressWarnings
1) @ Anular:
Al anular un método en la clase secundaria, debemos usar esta anotación para marcar ese método. Esto hace que el código sea legible y evita problemas de mantenimiento, tales como: al cambiar la firma del método de la clase padre, es necesario cambiar la firma en las clases secundarias (donde se usa esta anotación) de lo contrario el compilador generaría una compilación error. Esto es difícil de localizar si no ha utilizado esta anotación.
Ejemplo:
public class MyParentClass {
public void justaMethod() {
System.out.println("Parent class method");
}
}
public class MyChildClass extends MyParentClass {
@Override
public void justaMethod() {
System.out.println("Child class method");
}
}
Creo que el ejemplo se explica por sí mismo. Para obtener más información sobre esta anotación, consulte este artículo: @Override anotación incrustada.
2) @Deprecated
@ La anotación desactualizada indica que el elemento marcado (clase, método o campo) está desaprobado y ya no debe usarse. El compilador genera una advertencia cada vez que un programa usa un método, clase o campo que ya ha sido marcado con la anotación @Deprecated. Cuando un elemento está en desuso, también debe documentarse utilizando la etiqueta Javadoc @deprecated, como se muestra en el siguiente ejemplo. Tenga en cuenta la diferencia de mayúsculas y minúsculas con @Deprecated y @deprecated. @deprecated se utiliza con fines de documentación.
Ejemplo:
/**
* @deprecated
* reason for why it was deprecated
*/
@Deprecated
public void anyMethodHere(){
// Do something
}
Ahora, cada vez que un programa usa este método, el compilador genera una advertencia. Para obtener más información sobre esta anotación, consulte este artículo: Java – Anotación @Deprecated.
3) @SuppressWarnings
Esta anotación indica al compilador que ignore las advertencias específicas. Por ejemplo, en el siguiente código, estoy llamando a un método obsoleto (supongamos 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 eso advertencia de desaprobación.
@SuppressWarnings("deprecation")
void myMethod() {
myObject.deprecatedMethod();
}
Creando anotaciones personalizadas
- Las anotaciones se crean usando @interface, seguido del nombre de la anotación como se muestra en el siguiente ejemplo.
- Una anotación también puede contener elementos. Parecen métodos. Por ejemplo, en el siguiente código, tenemos cuatro elementos. No deberíamos proporcionar la implementación de estos elementos.
- Todas las anotaciones amplían la interfaz java.lang.annotation.Annotation. Las anotaciones no pueden incluir cláusulas de extensión.
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;
@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomAnnotation{
int studentAge() default 18;
String studentName();
String stuAddress();
String stuStream() default "CSE";
}
Nota: Cualquier elemento que tenga valores predeterminados establecidos al crear anotaciones se puede ignorar mientras se usa la anotación. Por ejemplo, si estoy aplicando la anotación anterior a una clase, lo haría así:
@MyCustomAnnotation(
studentName="Chaitanya",
stuAddress="Agra, India"
)
public class MyClass {
...
}
Como puede ver, no le hemos dado ningún valor al archivo. studentAge es stuStream elementos, ya que es opcional establecer los valores de estos elementos (los valores predeterminados ya se han establecido en la definición de la anotación, pero si lo desea, puede asignar un nuevo valor mientras usa la anotación de la misma manera que lo hicimos para los 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 anotación:
@interface MyCustomAnnotation {
int count();
String[] books();
}
Uso:
@MyCustomAnnotation(
count=3,
books={"C++", "Java"}
)
public class MyClass {
}
Volvamos al tema nuevamente: en el ejemplo de anotación personalizada usamos estas cuatro anotaciones: @Documented, @Target, @Inherited Y @Retention. Veámoslos en detalle.
@ Documentado
@ La anotación documentada indica que los elementos que utilizan esta anotación deben estar documentados por JavaDoc. Por ejemplo:
java.lang.annotation.Documented
@Documented
public @interface MyCustomAnnotation {
//Annotation body
}
@MyCustomAnnotation
public class MyClass {
//Class body
}
Mientras genera javadoc para la clase MyClass, la anotación @MyCustomAnnotation se incluiría en eso.
@Objetivo
Especifica dónde podemos usar la anotación. Por ejemplo: en el siguiente código, hemos definido el tipo de destino como METHOD, lo que significa que la anotación subyacente solo se puede usar en métodos.
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
public @interface MyCustomAnnotation {
}
public class MyClass {
@MyCustomAnnotation
public void myMethod()
{
//Doing something
}
}
Nota: 1) Si no define ningún tipo de Target, significa que la anotación se puede aplicar a cualquier elemento.
2) Además de ElementType.METHOD, una anotación puede tener los siguientes valores de destino posibles.
ElementType.METHOD
ElementType.PACKAGE
ElementType.PARAMETER
ElementType.TYPE
ElementType.ANNOTATION_TYPE
ElementType.CONSTRUCTOR
ElementType.LOCAL_VARIABLE
ElementType.FIELD
@Heredado
La anotación @Inherited indica que una anotación personalizada utilizada en una clase debe ser heredada por todas sus subclases. Por ejemplo:
java.lang.annotation.Inherited
@Inherited
public @interface MyCustomAnnotation {
}
@MyCustomAnnotation
public class MyParentClass {
...
}
public class MyChildClass extends MyParentClass {
...
}
Aqui la clase MyParentClass está usando anotación @MyCustomAnnotation marcado con la anotación @ heredada. Significa la subclase MyChildClass hereda el @MyCustomAnnotation.
@Retencion
Indica cuánto tiempo se deben conservar las anotaciones con el tipo anotado.
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
@interface MyCustomAnnotation {
}
Aquí hemos utilizado RetentionPolicy.RUNTIME. También hay otras dos opciones. Veamos qué significan:
RetentionPolicy.RUNTIME: La anotación debe 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 de “Anotación Java”. Si tiene alguna pregunta, no dude en dejar una línea a continuación.