Neste tutorial, aprenderemos o que são anotações, diferentes anotações Java e como usá-las com a ajuda de exemplos.
As anotações Java são metadados (dados sobre dados) para o código-fonte do nosso programa.
Eles fornecem informações adicionais sobre o programa ao compilador, mas não fazem parte do próprio programa. Essas anotações não afetam a execução do programa compilado.
As anotações começam com @. Sua sintaxe é:
@AnnotationName
Vamos dar um exemplo de @Overrideanotação.
A @Overrideanotação especifica que o método que foi marcado com esta anotação substitui o método da superclasse com o mesmo nome de método, tipo de retorno e lista de parâmetros.
Não é obrigatório usar @Overrideao substituir um método. No entanto, se o usarmos, o compilador fornecerá um erro se algo estiver errado (como o tipo de parâmetro errado) enquanto sobrescreve o método.
Exemplo 1: Exemplo de anotação @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(); ) )
Resultado
Eu sou um cão.
Neste exemplo, o método displayInfo()está presente na superclasse Animal e na subclasse Dog. Quando esse método é chamado, o método da subclasse é chamado em vez do método da superclasse.
Formatos de anotação
As anotações também podem incluir elementos (membros / atributos / parâmetros).
1. Anotações do marcador
As anotações do marcador não contêm membros / elementos. É usado apenas para marcar uma declaração.
Sua sintaxe é:
@AnnotationName ()
Como essas anotações não contêm elementos, os parênteses podem ser excluídos. Por exemplo,
@Sobrepor
2. Anotações de elemento único
Uma única anotação de elemento contém apenas um elemento.
Sua sintaxe é:
@AnnotationName (elementName = "elementValue")
Se houver apenas um elemento, é uma convenção nomear esse elemento como valor.
@AnnotationName (value = "elementValue")
Nesse caso, o nome do elemento também pode ser excluído. O nome do elemento será o valor por padrão.
@AnnotationName ("elementValue")
3. Anotações de vários elementos
Essas anotações contêm vários elementos separados por vírgulas.
Sua sintaxe é:
@AnnotationName (element1 = "value1", element2 = "value2")
Posicionamento de anotação
Qualquer declaração pode ser marcada com uma anotação, colocando-a acima dessa declaração. A partir do Java 8, as anotações também podem ser colocadas antes de um tipo.
1. Declarações acima
Conforme mencionado acima, as anotações Java podem ser colocadas acima das declarações de classe, método, interface, campo e outras declarações de elementos do programa.
Exemplo 2: Exemplo de anotação @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(); ) )
Resultado
Lista de palavras => (programiz)
Se o programa acima for compilado sem usar a @SuppressWarnings("unchecked")anotação, o compilador ainda irá compilar o programa, mas dará avisos como:
Main.java usa operações não verificadas ou não seguras. Lista de palavras => (programiz)
Estamos recebendo o aviso
Main.java usa operações não verificadas ou inseguras
por causa da seguinte declaração.
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.
- Instruções de tempo de execução - algumas anotações podem ser definidas para fornecer instruções ao programa em tempo de execução. Essas anotações são acessadas usando o Java Reflection.
