En Java, las anotaciones se usan para adjuntar metadatos a un elemento del programa, como una clase, método, instancias, etc. Algunas anotaciones se usan para anotar otras anotaciones. Este tipo de anotaciones se conocen como meta-anotaciones. @Retention también es una metaanotación que viene con algunas políticas de retención. Estas políticas de retención determinan en qué punto se descarta una anotación. Hay tres tipos de políticas de retención: SOURCE, CLASS y RUNTIME.
- RetentionPolicy.SOURCE: las anotaciones anotadas mediante la política de retención SOURCE se descartan en tiempo de ejecución.
- RetentionPolicy.CLASS: las anotaciones anotadas mediante la política de retención de CLASS se registran en el archivo .class pero se descartan durante el tiempo de ejecución. CLASS es la política de retención predeterminada en Java.
- RetentionPolicy.RUNTIME: Las anotaciones anotadas mediante la política de retención RUNTIME se conservan durante el tiempo de ejecución y se puede acceder a ellas en nuestro programa durante el tiempo de ejecución.
Implementación:
Aquí crearemos tres anotaciones personalizadas con políticas de retención como SOURCE, CLASS y RUNTIME. Estas anotaciones personalizadas se usan luego para anotar tres clases, a saber, A, B y C. En el método principal, verificamos si las anotaciones están adjuntas a las clases en tiempo de ejecución o no.
Ejemplo
Java
// Java Program to Illustrate Retention Annotations
// Importing required classes from java.lang package
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
// Here we will be creating 3 annotations with
// RetentionPolicy as SOURCE, CLASS, & RUNTIME
// Retention Annotation 1
@Retention(RetentionPolicy.SOURCE)
// Interface
@interface SourceRetention
{
String value() default "Source Retention";
}
// Retention Annotation 2
@Retention(RetentionPolicy.CLASS)
// Interface
@interface ClassRetention
{
String value() default "Class Retention";
}
// Retention Annotation 3
@Retention(RetentionPolicy.RUNTIME)
// Interface
@interface RuntimeRetention
{
String value() default "Runtime Retention";
}
// Annotating classes A, B, and C
// with our custom annotations
@SourceRetention
class A {
}
@ClassRetention
class B {
}
@RuntimeRetention
class C {
};
// Main class
public class RetentionPolicyDemo {
// Main driver method
public static void main(String[] args)
{
// Obtaining the array of annotations used to
// annotate class A, B, and C. Array a and b will be
// empty as their annotation are attached before
// runtime while array c will contain the
// RuntimeRetention annotation as it was marked with
// RUNTIME retention policy
Annotation a[]
= new A().getClass().getAnnotations();
Annotation b[]
= new B().getClass().getAnnotations();
Annotation c[]
= new C().getClass().getAnnotations();
// Printing the number of retained annotations of
// each class at runtime
System.out.println(
"Number of annotations attached to "
+ "class A at Runtime: " + a.length);
System.out.println(
"Number of annotations attached to "
+ "class B at Runtime: " + b.length);
System.out.println(
"Number of annotations attached to "
+ "class C at Runtime: " + c.length);
// Since the class C is annotated with an annotation
// which has retention policy as runtime so it
// can be accessed during runtime while annotations
// of other two classes are discarded before runtime
// so they can't be accessed
System.out.println(
"Annotation attached to class C: " + c[0]);
}
}
Number of annotations attached to class A at Runtime: 0 Number of annotations attached to class B at Runtime: 0 Number of annotations attached to class C at Runtime: 1 Annotation attached to class C: @RuntimeRetention(value="Runtime Retention")
Publicación traducida automáticamente
Artículo escrito por shivamsingh00141 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA