Símbolo de anotación @ en Java

1. La anotación @Override en Java
2. La anotación @SuppressWarnings en Java
3. La anotación @Deprecated en Java

Este artículo presentará el símbolo @, que se denomina anotaciones en Java. Nos centraremos en las anotaciones Java integradas como @Override, @SuppressWarnings y @Deprecated.

La anotación @Override en Java

La anotación es una forma de indicar la información adicional adjunta con una clase, interfaz y método en Java. El compilador de Java y la JVM utilizan la información proporcionada con el uso de anotaciones. Una anotación comienza con el símbolo @. La anotación @Override asegura que el método de la clase secundaria anula el método de la clase principal. Es una anotación de marcador porque no tiene valores ni elementos. Cuando usamos la anotación @Override, el compilador generará errores y nos advertirá si hay algún error al anular el método. Los probables errores que comprueba son el error de ortografía y los errores de argumento y tipo de retorno. Podemos demostrar el uso de la anotación @Override creando una herencia. En primer lugar, no usaremos la anotación, pero luego la usaremos para demostrar cómo funciona @Override.

Por ejemplo, cree una clase Parent y escriba un método message() con un tipo de retorno void. Imprime algunos mensajes dentro del método. Del mismo modo, cree otra clase, Child, y amplíe la clase Parent. Cree el mismo método message con el tipo void y escriba un mensaje en su interior. Justo antes del método, escriba la anotación @Override. Luego, dentro de la clase principal, cree objetos de cada una de las clases y llame al método message().

Aquí, la subclase hereda la superclase, y cada uno de los métodos de cada clase se invoca sin ningún problema.

Código de ejemplo:

class Annotation {
  public static void main(String[] args) {
    new Child().message();
    new Parent().message();
  }
}

class Parent {
  void message() {
    System.out.println("Invoked from the Parent class");
  }
}

class Child extends Parent {
  @Override
  void message() {
    System.out.println("Invoked from the Child class");
  }
}

Producción :

Invoked from the Child class
Invoked from the Parent class

Modifique el método message() en la clase Child en mesage(). Luego, ejecute el programa. Muestra la siguiente salida.

Producción :

Annotation.java:18: error: method does not override or implement a method from a supertype

Aquí, cambiamos el nombre del método. A veces, el programador puede cometer este tipo de errores al anular. Por lo tanto, la anotación @Override asegura cualquier error al anular un método y alerta al programador.

La anotación @SuppressWarnings en Java

La anotación @SuppressWarnings le dice al compilador que suprima o ignore el error para la parte especificada del código. Podemos usar la anotación para un tipo, campo, método, parámetro, constructor y variable local. Podemos especificar el valor sin marcar entre los paréntesis de la anotación como @SuppressWarnings("unchecked") para suprimir el error. Cuando usamos la anotación antes de la clase, suprimirá cualquier error dentro de la clase. Y cuando lo usamos antes que cualquier método dentro de una clase, solo suprimirá el error de esa clase en particular.

Por ejemplo, importe el paquete util y cree una clase llamada Annotation. Escriba @SuppressWarnings("unchecked") antes del método main. Dentro del método main, cree una instancia de ArrayList() y asígnela a la variable fruits. Luego, agregue los valores apple y mango con el método add(). Finalmente, imprima la variable fruits.

En el siguiente ejemplo, hemos importado todo del paquete util. Importa la clase ArrayList que usaremos después. El código anterior se ejecuta correctamente, aunque hay un error. Hemos utilizado la colección no genérica ArrayList. No hemos especificado el tipo dentro de un símbolo <>. Por tanto, el código es defectuoso. Pero se ejecuta porque hemos suprimido el error usando la anotación @SuppressWarnings.

Código de ejemplo:

import java.util.*;
class Annotation {
  @SuppressWarnings("unchecked")
  public static void main(String args[]) {
    ArrayList fruits = new ArrayList();
    fruits.add("apple");
    fruits.add("mango");
    System.out.println(fruits);
  }
}

Producción :

[apple, mango]

Si no usamos la anotación para el siguiente código, el compilador mostrará el siguiente error.

Producción :

Note: Annotation.java uses unchecked or unsafe operations.

La anotación @Deprecated en Java

La anotación @Deprecated se utiliza para denotar el fragmento de código especificado como código obsoleto. El compilador mostrará una advertencia de obsolescencia cuando usemos la anotación. Podemos anotar un tipo, método, campo y constructor usando la anotación @Deprecated.

Por ejemplo, cree una clase Car y cree un constructor con los parámetros color, length y width. Utilice la anotación @Deprecated antes del constructor. Deja el cuerpo vacío. Cree otro constructor y escriba un parámetro de cadena name en él. Cree otra clase, Annotation, y dentro del método main, llame a estos dos constructores.

En el siguiente ejemplo, hemos utilizado las anotaciones @Deprecated antes del primer constructor. Permite que el compilador genere una advertencia que indique que el constructor está obsoleto. De esta manera, podemos usar la anotación para especificar algo que está desaprobado en el código. No se recomienda eliminar el código obsoleto porque se puede usar para revertir a versiones anteriores si es necesario. Se alienta a que se utilice la nueva alternativa en tales casos.

Código de ejemplo:

class Annotation {
  public static void main(String args[]) {
    new Car("red", 550, 300);
    new Car("Lambo");
  }
}
class Car {
  @Deprecated
  Car(String color, int length, int width) {}
  Car(String name) {}
}

Producción :

Note: Annotation.java uses or overrides a deprecated API.