Introducción Anotaciones en Java
Las anotaciones se introdujeron o estuvieron disponibles en la versión 1.5 del Kit de desarrollo de Java (JDK). Las anotaciones en Java proporcionan más información sobre los datos presentes en la estructura del código, es decir, son datos sobre datos también conocidos como metadatos.
¿Qué son las anotaciones en Java?
Las anotaciones ayudan a definir los metadatos en el código de manera estandarizada. Además, las anotaciones ayudan a proporcionar instrucciones a su compilador de Java para seguir mientras compila ese código de Java.
Cuando usamos las anotaciones, usamos el signo '@' y luego seguimos el nombre de su anotación, para que el compilador la trate como una anotación. Es importante tener en cuenta que las anotaciones se pueden agregar antes de
- Una declaración de clase
- Una declaración de variable miembro
- Una declaración de constructor
- Una declaración de método
- Una declaración de parámetros
- Una declaración de variable local.
Los puntos importantes para recordar son que todas las anotaciones extienden java.lang.annotation.Annotation interface. Además, las anotaciones no pueden incluir ninguna cláusula extendida.
Anotaciones Java incorporadas
En Java, hay anotaciones integradas como @Override, @Deprecated, @SuppressWarnings que están diseñadas para un propósito específico y se usan en una de las situaciones anteriores, por ejemplo, solo para la clase o solo para el método, etc.
Ejemplo # 1 - Anulación
class Dad (
public void say() (
System.out.println("Do your homework");
)
)
public class Child extends Dad (
@Override
public void say()(
System.out.println("I wanna play");
)
public static void main(String args())(
Dad daddy = new Child();
daddy.say();
)
)
Salida
Ejemplo # 2 -Deprecado
public class Outdated
(
@Deprecated
public void oldShow()
(
System.out.println("This Method is deprecated"); )
public static void main(String args())
(
Outdated od = new Outdated ();
od.oldShow();
)
)
Salida
Meta anotaciones
Hay cinco tipos de metaanotaciones:
- Documentado: informa que el miembro o variable o clase que utiliza esta anotación debe ser documentado por Javadoc o cualquier otra herramienta similar disponible.
- Destino: se utiliza para especificar en qué tipo se utiliza la anotación. Se utiliza principalmente junto con sus anotaciones personalizadas.
- Heredado: marca la anotación que se heredará a la subclase.
- Retención: indica cuánto tiempo se deben retener las anotaciones con el tipo anotado. Toma el argumento de Política de retención cuyos valores posibles son: SOURCE, CLASS y RUNTIME.
- Repetible: esto informa que los tipos de anotación cuya declaración se anota son repetibles.
Ejemplo: documentación y retención
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@interface RSample (
String rentent();
)
@Documented
@interface DSample (
String doc();
)
public class MetaAnnotate (
public static void main(String arg())
(
new MetaAnnotate().rentent();
new MetaAnnotate().doc();
)
@RSample (rentent="Meta Info R")
public void rentent() (
System.out.println("Retention Policy Applied");
)
@DSample(doc="Meta Info D")
public void doc() (
System.out.println("Code Documented with the value");
)
)
Salida
Explicación
RetentionPolicy.RUNTIME: este valor especifica que el valor de la anotación debe estar disponible en tiempo de ejecución, para su inspección a través de la reflexión de Java.
Ejecute el comando Javadoc para ver la documentación de su código.
Tipos de anotaciones
Hay tres categorías de anotaciones y las siguientes:
1. Anotaciones de marcadores: estos tipos de anotaciones se utilizan como una declaración para notificar al desarrollador de qué se trata la función o clase a continuación, es decir, comparte información adicional sobre la función o clase, como si la función está anulando otra función o si la función está en desuso, etc. @Override, @Deprecated se consideran anotaciones de marcador.
Ejemplo: DemoAnnotation ()
2. Anotaciones de valor único: este tipo de anotación tiene un valor para especificar ese valor para ese miembro para el que se coloca la anotación y, por lo tanto, no es necesario especificar el nombre de ese miembro.
Ejemplo: DemoAnnotation ("custId123")
3. Anotaciones completas: este tipo de anotación toma múltiples valores, pares, miembros.
Ejemplo: DemoAnnotation (categoría = "Juguetes", valor = 1500)
Personalizado
La interfaz de usuario crea anotaciones personalizadas, seguidas de un nombre de anotación como veremos en el siguiente ejemplo.
Archivo 1: Anotación personalizada definida
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target((ElementType.TYPE, ElementType.METHOD))
@Retention(RetentionPolicy.RUNTIME)
@interface Magicians
(
String Wizard() default "Reynolds";
String House() default "Green";
)
@Magicians
public class Magician
(
@Magicians(Wizard = "Harry Potter", House = "Red")
public String getString() ( return null; )
)
Archivo 2: clase principal que llama a la clase de anotación personalizada
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
public class MyCustomAnnotation
(
public static void main(String() args) throws NoSuchMethodException, SecurityException
(
new Magician();
Class magic = Magician.class;
readAnnotationOn(magic);
Method method = magic.getMethod("getString", new Class()());
readAnnotationOn(method);
)
static void readAnnotationOn(AnnotatedElement element)
(
try
(
System.out.println("\n Find annotations on " + element.getClass().getName());
Annotation() annotations = element.getAnnotations();
for (Annotation annotation : annotations)
(
if (annotation instanceof Magicians)
(
Magicians mData = (Magicians) annotation;
System.out.println("Wizard Name :" + mData.Wizard());
System.out.println("Wizard House Color :" + mData.House());
)
)
) catch (Exception e)
(
e.printStackTrace();
)
)
)
Salida
Conclusión
En este artículo, aprendimos sobre qué son las anotaciones de Java y sus tipos con ejemplos, a lo largo vimos ejemplos de anotaciones incorporadas proporcionadas por Java y codificamos nuestras anotaciones personalizadas.
Aprendimos que las anotaciones son útiles para estandarizar el código y también ayudan a comprender mejor el código y su estructura.
Artículos recomendados
Esta es una guía de anotaciones de Java. Aquí discutimos cómo hacer anotaciones Java incorporadas con los ejemplos y resultados dados. También puede echar un vistazo a los siguientes artículos para obtener más información:
- Variables en Java
- Patrones en Java
- Clasificación rápida en Java
- Los mejores compiladores de Java
- instanceOf en Java con Ejemplo