Anotações Java
Anotações Java
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 programa em si. 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
@Override anotação. O
@Override annotation 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
@Override ao substituir um método. No entanto, se o usarmos, o compilador dará um erro se algo estiver errado (como o tipo de parâmetro errado) ao substituir 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();
}
}
Saída
I am a dog.
Neste exemplo, o método
displayInfo() está presente tanto na superclasse Animal e subclasse Cão . 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,
@Override
2. Anotações de elemento único
Uma anotação de elemento único 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á 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")
Colocação da anotação
Qualquer declaração pode ser marcada com 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
Como mencionado acima, as anotações Java podem ser colocadas acima de classes, métodos, interfaces, campos 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();
}
}
Saída
Word list => [programiz]
Se o programa acima for compilado sem usar o
@SuppressWarnings("unchecked") anotação, o compilador ainda compilará o programa, mas dará avisos como:Main.java uses unchecked or unsafe operations. Word list => [programiz]
Estamos recebendo o aviso
Main.java uses unchecked or unsafe operations
por causa da seguinte afirmação.
ArrayList wordList = new ArrayList<>();
Isso ocorre porque não definimos o tipo genérico da lista de matrizes. Podemos corrigir esse aviso especificando genéricos entre colchetes angulares
<> . ArrayList<String> wordList = new ArrayList<>();
2. Digite anotações
Antes do Java 8, as anotações podiam ser aplicadas apenas a declarações. Agora, as anotações de tipo também podem ser usadas. Isso significa que podemos colocar anotações onde quer que usemos um tipo.
Invocações de construtor
new @Readonly ArrayList<>()
Definições de tipo
@NonNull String str;
Esta declaração especifica a variável não nula str do tipo
String para evitar NullPointerException . @NonNull List<String> newList;
Esta declaração especifica uma lista não nula do tipo
String .
List<@NonNull String> newList;
Esta declaração especifica uma lista de valores não nulos do tipo
String . Tipo de conversões
newStr = (@NonNull String) str;
estenda e implementa cláusula
class Warning extends @Localized Message
cláusula de lançamento
public String readMethod() throws @Localized IOException
As anotações de tipo permitem que o código Java seja analisado melhor e fornecem verificações de tipo ainda mais fortes.
Tipos de anotações
1. Anotações predefinidas
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Meta-anotações
@Retention@Documented@Target@Inherited@Repeatable
3. Anotações personalizadas
Esses tipos de anotação são descritos em detalhes no tutorial Java Annotation Types.
Uso de anotações
- Instruções do compilador - As anotações podem ser usadas para dar instruções ao compilador, detectar erros ou suprimir avisos. As anotações internas
@Deprecated,@Override,@SuppressWarningssão usados para esses fins. - Instruções em tempo de compilação - As instruções em tempo de compilação fornecidas por essas anotações ajudam o software a criar ferramentas para gerar código, arquivos XML e muito mais.
- Instruções de tempo de execução - Algumas anotações podem ser definidas para dar instruções ao programa em tempo de execução. Essas anotações são acessadas usando o Java Reflection.
Java