Anotaciones Java
Anotaciones Java
En este tutorial, aprenderemos qué son las anotaciones, diferentes anotaciones de Java y cómo usarlas con la ayuda de ejemplos.
Las anotaciones de Java son metadatos (datos sobre datos) para el código fuente de nuestro programa.
Proporcionan información adicional sobre el programa al compilador, pero no forman parte del programa en sí. Estas anotaciones no afectan la ejecución del programa compilado.
Las anotaciones comienzan con @ . Su sintaxis es:
@AnnotationName
Tomemos un ejemplo de @Override anotación.
El @Override anotación especifica que el método que ha sido marcado con esta anotación anula el método de la superclase con el mismo nombre de método, tipo de devolución y lista de parámetros.
No es obligatorio usar @Override al anular un método. Sin embargo, si lo usamos, el compilador da un error si algo está mal (como un tipo de parámetro incorrecto) mientras anula el método.
Ejemplo 1:Ejemplo de anotación @Override
class Animal {
public void displayInfo() {
System.out.println("I am an animal.");
}
}
class Dog extends Animal {
@Override
public void displayInfo() {
System.out.println("I am a dog.");
}
}
class Main {
public static void main(String[] args) {
Dog d1 = new Dog();
d1.displayInfo();
}
}
Salida
I am a dog.
En este ejemplo, el método displayInfo() está presente tanto en la superclase Animal y subclase Perro . Cuando se llama a este método, se llama al método de la subclase en lugar del método de la superclase.
Formatos de anotación
Las anotaciones también pueden incluir elementos (miembros/atributos/parámetros).
1. Anotaciones de marcador
Las anotaciones de marcador no contienen miembros/elementos. Solo se usa para marcar una declaración.
Su sintaxis es:
@AnnotationName()
Dado que estas anotaciones no contienen elementos, se pueden excluir los paréntesis. Por ejemplo,
@Override
2. Anotaciones de un solo elemento
Una anotación de un solo elemento contiene solo un elemento.
Su sintaxis es:
@AnnotationName(elementName = "elementValue")
Si solo hay un elemento, es una convención nombrar ese elemento como valor .
@AnnotationName(value = "elementValue")
En este caso, el nombre del elemento también se puede excluir. El nombre del elemento será valor por defecto.
@AnnotationName("elementValue")
3. Anotaciones de elementos múltiples
Estas anotaciones contienen varios elementos separados por comas.
Su sintaxis es:
@AnnotationName(element1 = "value1", element2 = "value2")
Ubicación de anotaciones
Cualquier declaración se puede marcar con una anotación colocándola encima de esa declaración. A partir de Java 8, las anotaciones también se pueden colocar antes de un tipo.
1. Declaraciones anteriores
Como se mencionó anteriormente, las anotaciones de Java se pueden colocar encima de las declaraciones de clase, método, interfaz, campo y otros elementos del programa.
Ejemplo 2:Ejemplo de anotación @SuppressWarnings
import java.util.*;
class Main {
@SuppressWarnings("unchecked")
static void wordsList() {
ArrayList wordList = new ArrayList<>();
// This causes an unchecked warning
wordList.add("programiz");
System.out.println("Word list => " + wordList);
}
public static void main(String args[]) {
wordsList();
}
}
Salida
Word list => [programiz]
Si el programa anterior se compila sin usar el @SuppressWarnings("unchecked") anotación, el compilador aún compilará el programa pero dará advertencias como:
Main.java uses unchecked or unsafe operations. Word list => [programiz]
Estamos recibiendo la advertencia
Main.java uses unchecked or unsafe operations
debido a la siguiente declaración.
ArrayList wordList = new ArrayList<>();
Esto se debe a que no hemos definido el tipo genérico de la lista de arreglos. Podemos arreglar esta advertencia especificando genéricos dentro de paréntesis angulares <> .
ArrayList<String> wordList = new ArrayList<>();
2. Escribe anotaciones
Antes de Java 8, las anotaciones solo se podían aplicar a las declaraciones. Ahora, también se pueden usar anotaciones de tipo. Esto significa que podemos colocar anotaciones donde sea que usemos un tipo.
Invocaciones de constructores
new @Readonly ArrayList<>()
Definiciones de tipos
@NonNull String str;
Esta declaración especifica la variable no nula str de tipo String para evitar NullPointerException .
@NonNull List<String> newList;
Esta declaración especifica una lista no nula de tipo String .
List<@NonNull String> newList;
Esta declaración especifica una lista de valores no nulos de tipo String .
Tipo moldes
newStr = (@NonNull String) str;
extiende e implementa la cláusula
class Warning extends @Localized Message
cláusula de lanzamientos
public String readMethod() throws @Localized IOException
Las anotaciones de tipo permiten analizar mejor el código Java y proporcionan comprobaciones de tipo aún más sólidas.
Tipos de anotaciones
1. Anotaciones predefinidas
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Meta-anotaciones
@Retention@Documented@Target@Inherited@Repeatable
3. Anotaciones personalizadas
Estos tipos de anotaciones se describen en detalle en el tutorial Tipos de anotaciones de Java.
Uso de anotaciones
- Instrucciones del compilador - Las anotaciones se pueden utilizar para dar instrucciones al compilador, detectar errores o suprimir advertencias. Las anotaciones integradas
@Deprecated,@Override,@SuppressWarningsse utilizan para estos fines. - Instrucciones en tiempo de compilación - Las instrucciones de tiempo de compilación proporcionadas por estas anotaciones ayudan al software a crear herramientas para generar código, archivos XML y mucho más.
- Instrucciones de tiempo de ejecución - Se pueden definir algunas anotaciones para dar instrucciones al programa en tiempo de ejecución. Se accede a estas anotaciones utilizando Java Reflection.
Java