En este tutorial, aprenderemos qué son las anotaciones, las 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 @Overrideanotación.
La @Overrideanotación especifica que el método que se ha marcado con esta anotación anula el método de la superclase con el mismo nombre de método, tipo de retorno y lista de parámetros.
No es obligatorio utilizarlo @Overrideal 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) al anular 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
Yo soy un perro.
En este ejemplo, el método displayInfo()está presente tanto en la superclase Animal como en la 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 marcadores
Las anotaciones de marcador no contienen miembros / elementos. Solo se utiliza para marcar una declaración.
Su sintaxis es:
@AnnotationName ()
Dado que estas anotaciones no contienen elementos, se pueden excluir los paréntesis. Por ejemplo,
@Anular
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 (valor = "elementValue")
En este caso, el nombre del elemento también se puede excluir. El nombre del elemento será el valor predeterminado.
@AnnotationName ("elementValue")
3. Anotaciones de varios elementos
Estas anotaciones contienen varios elementos separados por comas.
Su sintaxis es:
@AnnotationName (elemento1 = "valor1", elemento2 = "valor2")
Colocació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 sobre 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
Lista de palabras => (programiz)
Si el programa anterior se compila sin usar la @SuppressWarnings("unchecked")anotación, el compilador aún compilará el programa, pero dará advertencias como:
Main.java utiliza operaciones no verificadas o inseguras. Lista de palabras => (programiz)
Estamos recibiendo la advertencia
Main.java utiliza operaciones no verificadas o inseguras
debido a la siguiente declaración.
ArrayList wordList = new ArrayList();
This is because we haven't defined the generic type of the array list. We can fix this warning by specifying generics inside angle brackets .
ArrayList wordList = new ArrayList();
2. Type annotations
Before Java 8, annotations could be applied to declarations only. Now, type annotations can be used as well. This means that we can place annotations wherever we use a type.
Constructor invocations
new @Readonly ArrayList()
Type definitions
@NonNull String str;
This declaration specifies non-null variable str of type String to avoid NullPointerException.
@NonNull List newList;
This declaration specifies a non-null list of type String.
List newList;
This declaration specifies a list of non-null values of type String.
Type casts
newStr = (@NonNull String) str;
extends and implements clause
class Warning extends @Localized Message
throws clause
public String readMethod() throws @Localized IOException
Type annotations enable Java code to be analyzed better and provide even stronger type checks.
Types of Annotations
1. Predefined annotations
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Meta-annotations
@Retention@Documented@Target@Inherited@Repeatable
3. Custom annotations
These annotation types are described in detail in the Java Annotation Types tutorial.
Use of Annotations
- Compiler instructions - Annotations can be used for giving instructions to the compiler, detect errors or suppress warnings. The built-in annotations
@Deprecated,@Override,@SuppressWarningsare used for these purposes. - Compile-time instructions - Compile-time instructions provided by these annotations help the software build tools to generate code, XML files and many more.
- Instrucciones en tiempo de ejecución : se pueden definir algunas anotaciones para dar instrucciones al programa en tiempo de ejecución. Se accede a estas anotaciones mediante Java Reflection.
