Tipos de anotaciones en Java: Guía completa de predefinidas, personalizadas y meta‑anotaciones

Tipos de anotaciones en Java

Este tutorial cubre anotaciones en Java —predefinidas, personalizadas y meta‑anotaciones— con ejemplos claros.

Las anotaciones en Java son metadatos que describen elementos en tu código fuente. La plataforma Java SE suministra un conjunto de anotaciones estándar, y los desarrolladores pueden crear las suyas propias adaptadas a sus proyectos. Las anotaciones también pueden ser anotadas a sí mismas, formando lo que se conoce como meta‑anotaciones.

Las anotaciones caen en tres categorías:

1. Anotaciones predefinidas – integradas en la plataforma Java.
2. Anotaciones personalizadas – definidas por el usuario para necesidades específicas.
3. Meta‑anotaciones – anotaciones aplicadas a otras anotaciones.

---

Tipos de anotaciones predefinidas

1. @Deprecated

El marcador @Deprecated señala que una clase, método, campo u otro elemento es obsoleto y tiene una alternativa más nueva. El compilador emite una advertencia cuando se usa un elemento deprecated.

Sintaxis:

@Deprecated public void metodoAntiguo() { ... }

Javadoc proporciona la etiqueta @deprecated para documentación:

/** * @deprecated * Usa {@link #nuevoMetodo()} en su lugar. */ @Deprecated public void metodoAntiguo() { ... }

Ejemplo

class Main { /** * @deprecated * Este método está deprecated y ha sido reemplazado por nuevoMetodo() */ @Deprecated public static void metodoDeprecated() { System.out.println("Método deprecated"); } public static void main(String[] args) { metodoDeprecated(); } }

Salida

Método deprecated

---

2. @Override

La anotación @Override indica que un método pretende sobrescribir un método de una superclase o interfaz. Aunque no es obligatoria, detecta errores como firmas no coincidentes en tiempo de compilación.

Ejemplo

class Animal { public void mostrar() { System.out.println("Soy un animal"); } } class Perro extends Animal { @Override public void mostrar() { System.out.println("Soy un perro"); } public void imprimirMensaje() { mostrar(); } } class Main { public static void main(String[] args) { Perro perro1 = new Perro(); perro1.imprimirMensaje(); } }

Salida

Soy un perro

---

3. @SuppressWarnings

Esta anotación instruye al compilador a ignorar categorías específicas de advertencias. Categorías comunes incluyen deprecation y unchecked.

Uso:

@SuppressWarnings("deprecation")

Múltiples categorías:

@SuppressWarnings({"deprecation", "unchecked"})

Ejemplo

class Main { @Deprecated public static void metodoDeprecated() { System.out.println("Método deprecated"); } @SuppressWarnings("deprecation") public static void main(String[] args) { Main objDep = new Main(); objDep.metodoDeprecated(); } }

Salida

Método deprecated

---

4. @SafeVarargs

Aplicada a métodos y constructores final, static o private, @SafeVarargs afirma que el método no realiza operaciones inseguras en su parámetro varargs. Esto elimina advertencias unchecked relacionadas con varargs.

Ejemplo

import java.util.*; class Main { @SafeVarargs private static void mostrarLista(List... listas) { for (List lista : listas) { System.out.println(lista); } } public static void main(String[] args) { List listaUniversidades = Arrays.asList("Universidad Tribhuvan", "Universidad Katmandú"); List listaLenguajes = Arrays.asList("Java", "C"); mostrarLista(listaUniversidades, listaLenguajes); } }

Salida

[Universidad Tribhuvan, Universidad Katmandú] [Java, C]

---

5. @FunctionalInterface

Introducida en Java 8, esta anotación designa una interfaz como interfaz funcional —una interfaz con un único método abstracto. El compilador verifica esta restricción.

Ejemplo

@FunctionalInterface public interface MiInterfazFunc { void primerMetodo(); // abstract }

Agregar un segundo método abstracto dispara error de compilación:

@FunctionalInterface public interface MiInterfazFunc { void primerMetodo(); void segundoMetodo(); // error en tiempo de compilación }

Múltiples métodos default o static son permitidos.

@FunctionalInterface public interface MiInterfazFunc { void primerMetodo(); default void segundoMetodo() { /* ... */ } default void tercerMetodo() { /* ... */ } }

---

Anotaciones personalizadas

Los desarrolladores pueden crear anotaciones que se ajusten a requisitos específicos de la aplicación. La sintaxis usa @interface y puede incluir métodos elemento con valores por defecto opcionales.

Sintaxis

@interface NombreAnotacion { TipoElemento nombreElemento() default valorPorDefecto; }

Ejemplo

@interface MiAnotacionPersonalizada { String value() default "valor por defecto"; } class Main { @MiAnotacionPersonalizada(value = "programiz") public void metodo1() { System.out.println("Método de prueba 1"); } public static void main(String[] args) { new Main().metodo1(); } }

Salida

Método de prueba 1

---

Meta‑anotaciones

Las meta‑anotaciones configuran cómo se comportan otras anotaciones.

1. @Retention

Define el alcance de visibilidad de una anotación: SOURCE, CLASS o RUNTIME.

@Retention(RetentionPolicy.RUNTIME) public @interface MiAnotacion { }

2. @Documented

Asegura que la anotación aparezca en Javadoc generado.

@Documented public @interface MiAnotacion { }

3. @Target

Restringe la anotación a elementos de programa específicos.

@Target(ElementType.METHOD) public @interface MiAnotacion { }

Tipos de elemento incluyen ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE.

4. @Inherited

Permite a una subclase heredar una anotación presente en una superclase.

@Inherited public @interface MiAnotacion { }

5. @Repeatable

Permite que una anotación se aplique múltiples veces al mismo elemento. Requiere una anotación contenedora.

@Repeatable(Universidades.class) public @interface Universidad { String nombre(); } public @interface Universidades { Universidad[] value(); }

Uso:

@Universidad(nombre = "TU") @Universidad(nombre = "KU") private String nombreUni;

---

Para acceder a datos de anotación en tiempo de ejecución, usa la API de Reflexión getAnnotationsByType() o getAnnotations().