Anotaciones en Java

Las anotaciones se utilizan para proporcionar información complementaria sobre un programa. 

• Las anotaciones comienzan con ‘ @ ‘.
• Las anotaciones no cambian la acción de un programa compilado.
• Las anotaciones ayudan a asociar metadatos (información) a los elementos del programa, es decir, variables de instancia, constructores, métodos, clases, etc.
• Las anotaciones no son comentarios puros, ya que pueden cambiar la forma en que el compilador trata un programa. Vea el código a continuación, por ejemplo.
• Básicamente, las anotaciones se utilizan para proporcionar información adicional, por lo que podrían ser una alternativa a las interfaces de marcador XML y Java.

Jerarquía de anotaciones en Java 

Implementación:

Nota: este programa arroja un error de compilación porque hemos mencionado la anulación, pero no la anulamos, hemos sobrecargado la pantalla.

Ejemplo:

// Java Program to Demonstrate that Annotations
// are Not Barely Comments
 
// Class 1
class Base {
   
    // Method
    public void display()
    {
        System.out.println("Base display()");
    }
}
 
// Class 2
// Main class
class Derived extends Base {
   
    // Overriding method as already up in above class
    @Override public void display(int x)
    {
        // Print statement when this method is called
        System.out.println("Derived display(int )");
    }
 
    // Method 2
    // Main driver method
    public static void main(String args[])
    {
        // Creating object of this class inside main()
        Derived obj = new Derived();
 
        // Calling display() method inside main()
        obj.display();
    }
}

Producción: 

10: error: method does not override or implement
    a method from a supertype

Si eliminamos el parámetro (int x) o eliminamos @override, el programa compila bien. 

Categorías de anotaciones

En términos generales, hay 5 categorías de anotaciones que se enumeran:

1. Anotaciones de marcador
2. Anotaciones de valor único
3. Anotaciones completas
4. Anotaciones de tipo
5. Anotaciones repetidas

Hablemos y agregaremos el código donde sea necesario, si es así. 

Categoría 1: Anotaciones de marcador

El único propósito es marcar una declaración. Estas anotaciones no contienen miembros y no constan de ningún dato. Por tanto, su presencia como anotación es suficiente. Dado que la interfaz de marcador no contiene miembros, basta con determinar simplemente si está presente o ausente. @Override es un ejemplo de anotación de marcador. 

Ejemplo

@TestAnnotation()

Categoría 2: Anotaciones de valor único 

Estas anotaciones contienen solo un miembro y permiten una forma abreviada de especificar el valor del miembro. Solo necesitamos especificar el valor para ese miembro cuando se aplica la anotación y no necesitamos especificar el nombre del miembro. Sin embargo, para usar esta abreviatura, el nombre del miembro debe ser un valor. 

Ejemplo

@TestAnnotation(“testing”);

Categoría 3: Anotaciones completas 

Estas anotaciones constan de múltiples miembros de datos, nombres, valores, pares. 

Ejemplo

@TestAnnotation(owner=”Rahul”, value=”Class Geeks”)

Categoría 4: Tipo de anotaciones 

Estas anotaciones se pueden aplicar a cualquier lugar donde se utilice un tipo. Por ejemplo, podemos anotar el tipo de retorno de un método. Estos se declaran anotados con la anotación @Target .

Ejemplo

// Java Program to Demonstrate Type Annotation
 
// Importing required classes
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
 
// Using target annotation to annotate a type
@Target(ElementType.TYPE_USE)
 
// Declaring a simple type annotation
@interface TypeAnnoDemo{}
 
// Main class
public class GFG {
   
    // Main driver method
    public static void main(String[] args) {
 
        // Annotating the type of a string
        @TypeAnnoDemo String string = "I am annotated with a type annotation";
        System.out.println(string);
        abc();
    }
 
    // Annotating return type of a function
    static @TypeAnnoDemo int abc() {
       
        System.out.println("This function's  return type is annotated");
       
        return 0;
    }
}

I am annotated with a type annotation
This function's  return type is annotated

Categoría 5: Anotaciones repetidas 

Estas son las anotaciones que se pueden aplicar a un solo elemento más de una vez. Para que una anotación sea repetible, debe anotarse con la anotación @Repeatable , que se define en el paquete java.lang.annotation . Su campo de valor especifica el tipo de contenedor para la anotación repetible. El contenedor se especifica como una anotación cuyo campo de valor es una array del tipo de anotación repetible. Por lo tanto, para crear una anotación repetible, primero se crea la anotación del contenedor y luego se especifica el tipo de anotación como argumento para la anotación @Repeatable.

Ejemplo:

// Java Program to Demonstrate a Repeatable Annotation
 
// Importing required classes
import java.lang.annotation.Annotation;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
 
// Make Words annotation repeatable
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(MyRepeatedAnnos.class)
@interface Words
{
    String word() default "Hello";
    int value() default 0;
}
 
// Create container annotation
@Retention(RetentionPolicy.RUNTIME)
@interface MyRepeatedAnnos
{
    Words[] value();
}
public class Main {
 
    // Repeat Words on newMethod
    @Words(word = "First", value = 1)
    @Words(word = "Second", value = 2)
    public static void newMethod()
    {
        Main obj = new Main();
 
        try {
            Class<?> c = obj.getClass();
 
            // Obtain the annotation for newMethod
            Method m = c.getMethod("newMethod");
 
            // Display the repeated annotation
            Annotation anno
                = m.getAnnotation(MyRepeatedAnnos.class);
            System.out.println(anno);
        }
        catch (NoSuchMethodException e) {
            System.out.println(e);
        }
    }
    public static void main(String[] args) { newMethod(); }
}

@MyRepeatedAnnos(value={@Words(value=1, word="First"), @Words(value=2, word="Second")})

 Anotaciones predefinidas/estándar

Java define popularmente siete anotaciones integradas como hemos visto en el diagrama de jerarquía.

• Cuatro se importan desde java.lang.annotation: @Retention , @Documented , @Target y @Inherited .
• Se incluyen tres en java.lang: @Deprecated, @Override y @SuppressWarnings

Anotación 1: @En desuso 

• Es una anotación de marcador. Indica que una declaración está obsoleta y ha sido reemplazada por un formulario más nuevo.
• La etiqueta Javadoc @deprecated debe usarse cuando un elemento ha quedado obsoleto.
• La etiqueta @deprecated es para documentación y la anotación @Deprecated es para reflexión en tiempo de ejecución.
• La etiqueta @deprecated tiene mayor prioridad que la anotación @Deprecated cuando ambas se usan juntas.

Ejemplo:

public class DeprecatedTest
{
    @Deprecated
    public void Display()
    {
        System.out.println("Deprecatedtest display()");
    }
 
    public static void main(String args[])
    {
        DeprecatedTest d1 = new DeprecatedTest();
        d1.Display();
    }
}

Deprecatedtest display()

Anotación 2: @Override

Es una anotación de marcador que solo se puede usar en métodos. Un método anotado con @Override debe anular un método de una superclase. Si no es así, se producirá un error en tiempo de compilación (ver esto por ejemplo). Se utiliza para garantizar que un método de superclase se anule realmente y no simplemente se sobrecargue.

Ejemplo

// Java Program to Illustrate Override Annotation
 
// Class 1
class Base
{
     public void Display()
     {
         System.out.println("Base display()");
     }
      
     public static void main(String args[])
     {
         Base t1 = new Derived();
         t1.Display();
     }    
}
 
// Class 2
// Extending above class
class Derived extends Base
{
     @Override
     public void Display()
     {
         System.out.println("Derived display()");
     }
}

Derived display()

Anotación 3: @SuppressWarnings 

Se utiliza para informar al compilador que suprima las advertencias específicas del compilador. Las advertencias para suprimir se especifican por nombre, en forma de string. Este tipo de anotación se puede aplicar a cualquier tipo de declaración.

Java agrupa las advertencias en dos categorías. Están en desuso y sin control . Cualquier advertencia no marcada se genera cuando un código heredado interactúa con un código que usa genéricos.

Ejemplo:

// Java Program to illustrate SuppressWarnings Annotation
 
// Class 1
class DeprecatedTest
{
    @Deprecated
    public void Display()
    {
        System.out.println("Deprecatedtest display()");
    }
}
 
// Class 2
public class SuppressWarningTest
{
    // If we comment below annotation, program generates
    // warning
    @SuppressWarnings({"checked", "deprecation"})
    public static void main(String args[])
    {
        DeprecatedTest d1 = new DeprecatedTest();
        d1.Display();
    }
}

Deprecatedtest display()

Anotación 4: @Documentado 

Es una interfaz de marcador que le dice a una herramienta que se debe documentar una anotación. Las anotaciones no se incluyen en los comentarios de ‘Javadoc’. El uso de la anotación @Documented en el código permite que herramientas como Javadoc lo procesen e incluyan la información del tipo de anotación en el documento generado.

Anotación 5: @Objetivo 

Está diseñado para usarse solo como una anotación a otra anotación. @Target toma un argumento, que debe ser constante de la enumeración ElementType . Este argumento especifica el tipo de declaraciones a las que se puede aplicar la anotación. Las constantes se muestran a continuación junto con el tipo de declaración al que corresponden.

Podemos especificar uno o más de estos valores en una anotación @Target . Para especificar múltiples valores, debemos especificarlos dentro de una lista delimitada por llaves. Por ejemplo, para especificar que una anotación se aplica solo a campos y variables locales, puede usar esta anotación @Target: @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE}) @Retention Annotation Determina dónde y cuánto tiempo se retiene la anotación . Los 3 valores que puede tener la anotación @Retention:

• FUENTE: Las anotaciones se conservarán en el nivel de fuente y el compilador las ignorará.
• CLASE: las anotaciones se conservarán en tiempo de compilación y la JVM las ignorará.
• TIEMPO DE EJECUCIÓN: estos se conservarán en tiempo de ejecución.

Anotación 6: @Heredado 

@Inherited es una anotación de marcador que solo se puede usar en la declaración de anotación. Solo afecta a las anotaciones que se utilizarán en las declaraciones de clase. @Inherited hace que la anotación de una superclase sea heredada por una subclase. Por lo tanto, cuando se realiza una solicitud de una anotación específica a la subclase, si esa anotación no está presente en la subclase, se verifica su superclase. Si esa anotación está presente en la superclase y si se anota con @Inherited, se devolverá esa anotación. 

Anotación 7: Definido por el usuario (Personalizado) 

Las anotaciones definidas por el usuario se pueden utilizar para anotar elementos del programa, es decir, variables, constructores, métodos, etc. Estas anotaciones se pueden aplicar justo antes de la declaración de un elemento (constructor, método, clases, etc.). 

Sintaxis: Declaración

[Access Specifier] @interface<AnnotationName>
{         
   DataType <Method Name>() [default value];
}

Mantenga estos puntos determinados como reglas para las anotaciones personalizadas antes de implementar las anotaciones definidas por el usuario. 

1. AnnotationName es una interfaz.
2. El parámetro no debe asociarse con declaraciones de métodos y la cláusula throws no debe usarse con declaraciones de métodos.
3. Los parámetros no tendrán un valor nulo, pero pueden tener un valor predeterminado.
4. el valor predeterminado es opcional.
5. El tipo de retorno del método debe ser primitivo, enumeración, string, nombre de clase o array de tipo primitivo, enumeración, string o nombre de clase.

Ejemplo:

// Java Program to Demonstrate User-defined Annotations
 
package source;
 
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
 
// User-defined annotation
@Documented
@Retention(RetentionPolicy.RUNTIME)
@ interface TestAnnotation
{
    String Developer() default "Rahul";
    String Expirydate();
} // will be retained at runtime
 
// Driver class that uses @TestAnnotation
public class Test
{
    @TestAnnotation(Developer="Rahul", Expirydate="01-10-2020")
    void fun1()
    {
        System.out.println("Test method 1");
    }
 
    @TestAnnotation(Developer="Anil", Expirydate="01-10-2021")
    void fun2()
    {
        System.out.println("Test method 2");
    }
     
    public static void main(String args[])
    {
        System.out.println("Hello");
    }
}

Producción: 

Hello

Este artículo es una contribución de Rahul Agrawal. Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.