Anotaciones en Java: Tipos, Usos y Ejemplos

Una anotación en un lenguaje de programación como Java se refiere a los metadatos sintácticos que se pueden integrar con el código fuente de Java. Se pueden anotar varios factores, como paquetes Java, variables, clases, parámetros y métodos. Los desarrolladores pueden leer fácilmente las anotaciones de Java directamente desde los archivos fuente, al igual que las etiquetas de Javadoc.

Las anotaciones de Java también se pueden incluir y leer desde los archivos de clase de Java de salida del compilador de Java. Esto permite que la máquina virtual Java mantenga anotaciones y las lea a través de un reflejo en tiempo de ejecución. En Java, es posible construir meta-anotaciones a partir de las existentes.

Estos son algunos conceptos básicos de las anotaciones en Java:

1. Las anotaciones siempre comienzan con una '@'. Por ejemplo: '@override', '@target', '@SuppressWarnings', etc.
2. Las anotaciones no afectan el comportamiento de un programa compilado.
3. Las anotaciones ayudan a asociar metadatos a componentes del programa como métodos, clases, variables, etc.
4. Las anotaciones no son solo comentarios, ya que pueden afectar la forma en que el compilador procesa un programa. Ofrecen información adicional del compilador sobre el programa, pero no forman parte del programa en sí. Por lo tanto, estas anotaciones no afectan la ejecución del programa compilado.

Tipos de anotaciones en Java

1. Anotaciones de valor único

Las anotaciones de valor único permiten solo una forma abreviada ya que contienen solo un miembro. El miembro debe recibir un valor posterior a la aplicación de la anotación. Sin embargo, no es necesario especificar el nombre de la anotación. El miembro debe tener un valor si se va a utilizar la abreviatura. Por ejemplo:

@TestAnnotation(“prueba”);

2. Anotaciones completas

Las anotaciones completas constan de varios datos, como miembros de datos, valores, pares y nombres.

Por ejemplo:

@TestAnnotation(propietario=”Rahul”, valor=”Class Geeks”)

Aprenda cursos de desarrollo de software en línea de las mejores universidades del mundo. Obtenga Programas PG Ejecutivos, Programas de Certificado Avanzado o Programas de Maestría para acelerar su carrera.

3. Repetición de anotaciones

Cuando una anotación se puede aplicar a objetos singulares más de una vez, se etiqueta como una anotación repetitiva. Las anotaciones repetidas se especifican con la etiqueta @Repeatable tal como se define en el paquete java.lang.annotation. Su campo de valor indica el tipo de contenedor de la anotación repetida.

El contenedor se define como una anotación con un campo de valor que contiene una matriz de anotaciones repetidas. Para construir una anotación repetida, primero cree la anotación del contenedor y luego especifique el tipo de anotación como una entrada para la anotación @Repeatable.

Por ejemplo:

// Programa Java para demostrar una anotación repetible

// Importando clases requeridas

importar java.lang.annotation.Annotation;

importar java.lang.anotación.Repetible;

importar java.lang.annotation.Retention;

importar java.lang.annotation.RetentionPolicy;

importar java.lang.reflect.Method;

// Hacer que la anotación de Words sea repetible

@Retención(RetenciónPolicy.RUNTIME)

@Repetible(MisAnnosRepetidos.clase)

Palabras de la @interfaz

{

String word() por defecto “Hola”;

int valor () por defecto 0;

}

// Crear anotación de contenedor

@Retención(RetenciónPolicy.RUNTIME)

@interfaz MisAnnosRepetidos

{

Palabras[] valor();

}

clase pública Principal {

// Repetir palabras en newMethod

@Palabras(palabra = “Primero”, valor = 1)

@Palabras(palabra = “Segundo”, valor = 2)

public static void newMethod()

{

Obj principal = nuevo Principal();

probar {

Clase<?> c = obj.getClass();

// Obtener la anotación para newMethod

Método m = c.getMethod(“nuevoMetodo”);

// Mostrar la anotación repetida

Anotación anno

= m.getAnnotation(MyRepeatedAnnos.class);

System.out.println(anno);

}

captura (NoSuchMethodException e) {

Sistema.salida.println(e);

}

}

public static void main(String[] args) { newMethod(); }

}

El resultado final sería: @MyRepeatedAnnos(value={@Words(value=1, word=”First”), @Words(value=2, word=”Second”)})

Explore nuestros cursos populares de ingeniería de software

3. Anotaciones de marcador

Las anotaciones de marcador solo tienen fines de declaración. Esta anotación tampoco contiene ningún miembro ni existe ningún dato dentro de ella. Su único propósito es mantener una presencia como una anotación. Por ejemplo: @Override.

4. Escriba anotaciones

Estas anotaciones se pueden usar en cualquier lugar donde se use un tipo. Por ejemplo, podemos anotar el tipo de devolución de un método. Las anotaciones de tipo se etiquetan con la anotación @Target.

Los códigos que pueden ilustrar las anotaciones de tipo son:

// Importando clases requeridas

importar java.lang.annotation.ElementType;

importar java.lang.annotation.Target;

// Uso de la anotación de destino para anotar un tipo

@Objetivo(TipoElemento.TYPE_USE)

// Declarar una anotación de tipo simple

@tipo de interfazAnnoDemo{}

// Clase principal

clase pública GFG {

// Método del controlador principal

public static void main(String[] args) {

// Anotando el tipo de una cadena

@TypeAnnoDemo String string = “Este código está anotado con una anotación de tipo”;

System.out.println(cadena);

a B C();

}

// Anotando el tipo de retorno de una función

estático @TypeAnnoDemo int abc() {

System.out.println(“El tipo de retorno de esta función está anotado”);

devolver 0;

}

Ejemplos de anotaciones predefinidas

Hay muchas variedades de anotaciones predefinidas que hemos mencionado anteriormente. Echemos un vistazo:

1. @Anular

Esta anotación de marcador solo se puede usar en métodos. Cualquier método con la anotación @override debe reemplazar a otro método de una superclase. Si esto falla, se activa un error en tiempo de compilación. Esto sucede porque debe garantizar que la superclase se anule y no solo se sobrecargue.

El código que puede ilustrar la anotación de anulación es:

// Clase 1

base de clase

{

Visualización de vacío público ()

{

System.out.println(“Visualización base()”);

}

public static void main(String args[])

{

Base t1 = nuevo Derivado();

t1.Pantalla();

}

}

// Clase 2

// Extendiendo por encima de la clase

clase Derivado extiende Base

{

@Anular

Visualización de vacío público ()

{

System.out.println(“Visualización derivada()”);

}

}

2. @Objetivo

Solo está destinado a ser utilizado como una anotación a otra anotación. @Target acepta un parámetro, que debe ser una constante ElementType. El parámetro decide a qué declaraciones se puede aplicar. La anotación @Target puede tener múltiples valores en lugar de solo un valor singular. Sin embargo, si se deben declarar varios valores, debe estar en forma de llaves como: @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE}).

La anotación @Retention se puede utilizar aquí para determinar el estado de retención de la anotación. Tres factores afectan una anotación @Retention:

• Fuente: el compilador ignora las anotaciones, ya que generalmente se mantienen en el nivel de fuente.
• Runtime: Se conserva en tiempo de ejecución.
• Clase: las anotaciones permanecen en tiempo de compilación y el programa Java las ignora.

3. @heredado

Esta anotación solo se puede usar con fines de declaración y, por lo tanto, solo afecta a ciertas declaraciones de clase. Una anotación puede reemplazar a la otra y heredar sus propiedades. Por lo tanto, la superclase se puede verificar si las anotaciones específicas están ausentes de la subclase. Sin embargo, si la anotación está presente, obtiene la anotación @Inherited.

Por ejemplo:

// Clase 1

clase PruebaDepreciada

{

@Obsoleto

Visualización de vacío público ()

{

System.out.println(“Pantalla de prueba obsoleta()”);

}

}

// Clase 2

clase pública SuppressWarningTest

{

// Si comentamos debajo de la anotación, el programa genera

// advertencia

@SuppressWarnings({“marcado”, “obsoleto”})

public static void main(String args[])

{

PruebaDepreciada d1 = nueva PruebaDepreciada();

d1.Pantalla();

}

}

Conclusión

Aquí, hemos aprendido acerca de las anotaciones en Java. También hemos aprendido sobre los tipos de anotaciones en Java y sus usos que pueden ayudar a los desarrolladores de Java a crear programas robustos y escalables con facilidad.

Si desea obtener más información sobre los conceptos de Java, la Certificación PG vinculada al trabajo de upGrad en ingeniería de software es su mejor opción para obtener una comprensión integral de los lenguajes de programación como Java, HTML, JS, así como otras herramientas y bibliotecas de desarrollo de software.

El programa está diseñado para estudiantes de último año o graduados desempleados que buscan asegurar puestos de nivel de entrada en el campo. El curso de 5 meses cubre la especialización en MERN/Cloud-Native y ayuda a los estudiantes a crear un portafolio de primera clase al exponerlos a 5 proyectos prácticos.

Entonces, no esperes. ¡Dirígete a upGrad y reserva tu asiento hoy!