CKTIS / Java
Tipos de anotación — @interface
Una declaración @interface define un tipo de anotación, es decir, metadatos asociados al código. Sus elementos describen los datos de la anotación, mientras que las meta-anotaciones controlan dónde se permite usarla, su retención, repetición y herencia.
Versión: Java SE 21; repository runtime, production runtime not attested
Sintaxis
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
@interface Label {
String value();
int priority() default 0;
}@interface define un tipo de anotación. Un elemento como String value(); es un método sin parámetros y sin cuerpo. Los tipos permitidos son los primitivos, String, Class, los enums, los tipos de anotación y sus matrices unidimensionales; el valor no puede ser null. Un elemento sin default es obligatorio. @Label("demo") abrevia @Label(value = "demo") cuando los demás elementos tienen valores predeterminados.
@Retention controla cuánto tiempo se conservan los metadatos: RetentionPolicy.SOURCE significa que el compilador los descarta; RetentionPolicy.CLASS significa que se guardan en el archivo de clase, sin garantizar que estén disponibles mediante reflexión; RetentionPolicy.RUNTIME significa que se conservan durante la ejecución. Sin embargo, el acceso mediante reflexión depende de dónde se use la anotación. Por ejemplo, una anotación con RetentionPolicy.RUNTIME que se aplica al uso de un tipo en una conversión explícita (cast) puede guardarse en el archivo de clase, pero la API de reflexión estándar de Java SE 21 no permite acceder a ella. Las anotaciones que se aplican a declaraciones de variables locales o de parámetros de expresiones lambda no se guardan en el archivo de clase, ni siquiera con RetentionPolicy.RUNTIME. Si no se especifica @Retention, se aplica RetentionPolicy.CLASS. Una anotación no ejecuta lógica por sí misma: una herramienta o el código debe interpretarla.
@Target restringe los lugares donde se permite usar la anotación. ElementType.TYPE abarca las declaraciones de clases, interfaces, enums y records; ElementType.FIELD abarca los campos, incluidas las constantes de enum; ElementType.METHOD abarca los métodos; ElementType.CONSTRUCTOR abarca los constructores. ElementType.TYPE no significa cualquier uso de un tipo: para eso existe ElementType.TYPE_USE.
@Repeatable indica un contenedor que permite repetir anotaciones del mismo tipo. El contenedor declara value(), que devuelve una matriz del tipo repetido, y sus demás elementos deben tener valores predeterminados. También debe cumplir las reglas de compatibilidad del JLS sobre retención, objetivos y meta-anotaciones.
@Inherited permite que las consultas de reflexión adecuadas sobre anotaciones de clase busquen en las superclases. No transfiere las anotaciones de las interfaces implementadas ni hace que se hereden las anotaciones de métodos, campos o constructores. El ejemplo muestra cuatro objetivos permitidos y lee un valor explícito y otro predeterminado.
Ejemplos
import java.lang.annotation.*;
public class Main {
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD,
ElementType.METHOD, ElementType.CONSTRUCTOR})
public @interface Label {
String value();
int priority() default 0;
}
@Label("demo")
static class Item {
@Label("id")
int id;
@Label("create")
Item() {}
@Label(value = "read", priority = 2)
void read() {}
}
public static void main(String[] args) throws ReflectiveOperationException {
Label type = Item.class.getAnnotation(Label.class);
Label method = Item.class.getDeclaredMethod("read").getAnnotation(Label.class);
System.out.println(type.value() + ":" + type.priority());
System.out.println(method.value() + ":" + method.priority());
}
}Resultado
demo:0 read:2
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.