Comprensión de las anotaciones de Java – Tutorial de @annotations de Java

Publicado: 2019-10-22
Anotaciones a nivel de paquete

¿Cómo y dónde se usan las anotaciones en Java?

Una anotación, en el lenguaje de programación de computadoras Java, es una forma especial de metadatos sintácticos que se pueden agregar al código fuente de Java.

Se pueden anotar clases, métodos, variables, parámetros y paquetes. A diferencia de las etiquetas de Javadoc, las anotaciones de Java pueden reflejarse en el sentido de que se pueden incrustar en archivos de clase generados por el compilador y la VM de Java puede retenerlas para que se puedan recuperar en tiempo de ejecución.

Es posible crear meta-anotaciones a partir de las existentes en Java, lo que hace que este concepto sea más sofisticado.

Java define un conjunto de anotaciones que están integradas en el lenguaje.

Comprender las anotaciones de Java - Consejos de Crunchify
Comprender las anotaciones de Java: consejos de Crunchify

Anotaciones aplicadas al código Java:

  • @Override : comprueba que la función es una anulación. Provoca una advertencia de compilación si la función no se encuentra en una de las clases principales.
  • @Deprecated : marca la función como obsoleta. Causa una advertencia de compilación si se usa la función.
  • @SuppressWarnings : indica al compilador que suprima las advertencias de tiempo de compilación especificadas en los parámetros de anotación.

Anotaciones aplicadas a otras anotaciones:

  • @Retention : especifica cómo se almacena la anotación marcada, ya sea solo en código, compilada en la clase o disponible en tiempo de ejecución a través de la reflexión.
  • @Documentado : marca otra anotación para su inclusión en la documentación.
  • @Target : marca otra anotación para restringir a qué tipo de elementos Java se puede aplicar la anotación.
  • @Inherited : marca otra anotación para que se herede en las subclases de la clase anotada (por defecto, las anotaciones no se heredan en las subclases).

Echemos un vistazo a estos a través de ejemplos de ejemplo:

1) @Override Anotación:

Su presencia indica al compilador que el método anotado debe anular un método de superclase existente.

El caso de uso más común para @Override es con métodos de objetos :

1
2
3
4
@ Override
public int hashValue ( ) {
     System . out . Println ( "This method is using @Override Annotation" ) ;
}

La razón principal por la que se creó @Override fue para solucionar errores tipográficos simples.

Por ejemplo, un método declarado erróneamente como

1
public int hashvalue ( ) { . . . }

de hecho, no es una anulación: el nombre del método tiene todas las letras en minúsculas, por lo que no coincide exactamente con el nombre del método hashValue() . Sin embargo, compilará perfectamente bien. Tal error es fácil de cometer y difícil de atrapar, lo cual es una combinación peligrosa. El uso de la anotación @Override le impide cometer tales errores.

Debe tener el hábito de usar @Override siempre que anule un método de superclase.

Comprender las anotaciones de Java

2) @Anotación en desuso:

Esta anotación indica que el elemento marcado está obsoleto y ya no debe utilizarse. El compilador genera una advertencia cada vez que un programa usa un método, una clase o un campo con la anotación @Deprecated .

Cuando un elemento está en desuso, también debe documentarse con la etiqueta Javadoc @deprecated , como se muestra en el siguiente ejemplo.

1
2
3
4
< strong > @ Deprecated < / strong >
static void deprecatedMethod ( ) {
     System . out . Println ( "This method is Deprecated.." ) ;
}

3) Anotación @SuppressWarnings:

Solo dígale al compilador, por favor no grite. Sé lo que estoy haciendo .

1
2
3
4
@ SuppressWarnings ( "serial" )
public class OldCode implements Serializable {
System . out . Println ( "This is Old Code.." ) ;
}

4) @Anotación de retención:

La anotación de retención indica dónde y durante cuánto tiempo se deben retener las anotaciones de este tipo.

Hay tres valores:

  • RetentionPolicy.SOURCE —Las anotaciones con este tipo se retendrán solo en el nivel de origen y el compilador las ignorará.
  • RetentionPolicy.CLASS —El compilador retendrá las anotaciones con este tipo en el momento de la compilación, pero la máquina virtual las ignorará.
  • RetentionPolicy.RUNTIME : la máquina virtual conservará las anotaciones con este tipo para que solo se puedan leer en tiempo de ejecución.
1
2
3
4
@ Retention ( RetentionPolicy . RUNTIME )
public @ interface Crunchify_Retention {
   String returnSomething ( ) ;
}

5) @Anotación documentada:

1
2
3
4
@ Documented
public @ interface Crunchify_Documented {
   String writeDocument ( ) ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DocumentedAnnotations {
   public static void main ( String arg [ ] ) {
       new DocumentedAnnotations ( ) . performRetention ( ) ;
       new DocumentedAnnotations ( ) . performDocumented ( ) ;
   }
   @ Crunchify_Retention ( returnSomething = "Hello retention test" )
   public void performRetention ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Retention'" ) ;
   }
   @ Crunchify_Documented ( writeDocument = "Hello document" )
   public void performDocumented ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Documented'" ) ;
   }
}

Ahora intente ejecutar el comando Java Doc y vea el resultado.

6) Anotación @Target:

Target indica qué elemento(s) de programa se pueden anotar utilizando instancias del tipo de anotación anotado. El valor de Target es uno de los miembros de la enumeración java.lang.annotation.ElementType :

  1. TIPO_ANOTACIÓN. El tipo de anotación anotado se puede utilizar para anotar la declaración del tipo de anotación.
  2. CONSTRUCTOR. El tipo de anotación anotado se puede usar para anotar la declaración del constructor.
  3. CAMPO. El tipo de anotación anotado se puede utilizar para anotar la declaración de campo.
  4. VARIABLE LOCAL. El tipo de anotación anotado se puede utilizar para anotar declaraciones de variables locales.
  5. MÉTODO. El tipo de anotación anotado se puede utilizar para anotar la declaración del método.
  6. PAQUETE. El tipo de anotación anotado se puede utilizar para anotar declaraciones de paquetes.
  7. PARÁMETRO. El tipo de anotación anotado se puede utilizar para anotar declaraciones de parámetros.
  8. ESCRIBE. El tipo de anotación anotado se puede utilizar para anotar declaraciones de tipo.
1
2
3
4
@ Target ( value = METHOD )
You can have multiple values in the Target annotation .
 
@ Target ( value = { TYPE , FIELD , METHOD , PARAMETER , CONSTRUCTOR , LOCAL_VARIABLE } )

7) @Anotación heredada:

Exactamente como suena el nombre, las subclases de un tipo anotado heredan un tipo de anotación @Inherited .

1
2
3
4
5
6
7
8
9
10
@ Inherited
@ interface ForEveryone { }
 
@ interface JustForMe { }
 
@ ForEveryone
@ JustForMe
class Superclass { }
 
class Subclass extends Superclass { }

En este ejemplo, Superclass se ha anotado explícitamente con @ForEveryone y @JustForMe . Subclass no se ha marcado explícitamente con ninguna de las dos; sin embargo, hereda @ForEveryone porque este último está anotado con @Inherited .

@JustForMe no está anotado, por lo que Subclass no lo hereda.

Aquí hay anotaciones de nivel de clase

anotaciones de nivel de clase