Tutoriais Básicos de Java

Controle de fluxo Java

Java Array

Java Orientação a Objetos (I)

Java Orientação a Objetos (II)

Java Orientação a Objetos (III)

Tratamento de Exceções Java

Java Lista (List)

Java Fila (Queue)

Java Conjuntos Map

Java Conjuntos Set

Java Entrada e Saída (I)/O)

Java Reader/Writer

Outros tópicos Java

Java Method Overloading Java try-with-resources

Anotação (Annotations) Java

Neste tutorial, vamos aprender o que são anotações, diferentes anotações Java e como usá-las por meio de exemplos.

As anotações Java são metadados de nosso código-fonte (dados sobre dados).

Elas fornecem informações adicionais ao compilador sobre o programa, mas não fazem parte do programa compilado. Essas anotações não afetam a execução do programa compilado.

As anotações começam com @. Sua sintaxe é:

@AnnotationName

Vamos usar a anotação @Override como exemplo.

@Override anotação especifica que o método marcado com essa anotação está sobrescrevendo o método da classe pai com o mesmo nome, tipo de retorno e lista de parâmetros.

Ao reescrever métodos, não é necessário usar @Override. No entanto, se o usarmos, o compilador fornecerá um erro ao reescrever o método, se ocorrer um erro (por exemplo, tipo de parâmetro incorreto).

Exemplo1:@Override anotação exemplo

class Animal {
　　public void displayInfo() {
　　　　System.out.println("Eu sou um animal.");
　　}
}
class Dog extends Animal {
　　@Override
　　public void displayInfo() {
　　　　System.out.println("Eu sou um cachorro.");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog d1　= new Dog();
　　　　d1.displayInfo();
　　}
}

resultados de saída

Eu sou um cachorro.

Neste exemplo, o método displayInfo() existe tanto na classe pai Animal quanto na classe filha Dog. Ao chamar esse método, será chamado o método da subclasse, não o método da superclasse.

Formato da anotação

As anotações também podem incluir elementos (membros/Atributo/Parâmetros).

1.Anotações de marcação

Anotações de marcação não contêm membros/Elemento. Ele é usado apenas para marcar declarações.

Sua sintaxe é:

@AnnotationName()

Devido a essas anotações não contiverem elementos, não é necessário usar parênteses. Por exemplo,

@Override

2.Anotações de elementos únicos

Anotações de elementos únicos contêm apenas um elemento.

Sua sintaxe é:

@AnnotationName(elementName = "elementValue")

Se houver apenas um elemento, é costume nomear esse elemento como value.

@AnnotationName(value = "elementValue")

Neste caso, também pode ser removido o nome do elemento. O nome do elemento padrão é value.

@AnnotationName("elementValue")

3.Múltiplos elementos de anotação

Essas anotações contêm vários elementos separados por vírgula.

Sua sintaxe é:

@AnnotationName(element1　= "value1", element2　= "value2")

Posição da anotação

Qualquer declaração pode ser marcada por comentários colocados acima dela. A partir do Java 8A partir de então, os comentários também podem ser colocados antes do tipo.

1.在声明语句上方

Como mencionado anteriormente, os comentários Java podem ser colocados acima das declarações de classes, métodos, interfaces, campos e outros elementos do programa.

Exemplo2：@SuppressWarnings注释示例

import java.util.*;
class Main {
　　@SuppressWarnings("unchecked")
　　static void wordsList() {
　　　　ArrayList wordList = new ArrayList<>();
　　　　//Isto levará a avisos não verificados
　　　　wordList.add("w"}}3codebox");　
　　　　System.out.println("Word list => "　+　wordList);
　　}
　　public static void main(String args[]) {
　　　　wordsList();
　　}
}

resultados de saída

Word list => [w3codebox]

Se o programa acima for compilado sem a anotação @SuppressWarnings("unchecked"), o compilador ainda compilará o programa, mas fornecerá o seguinte aviso:

Main.java usa operações não verificadas ou inseguras.
Word list => [w3codebox]

recebemos o aviso

Main.java usa operações não verificadas ou inseguras

porque das seguintes declarações.

ArrayList wordList = new ArrayList<>();

Isso é porque ainda não definimos o tipo genérico da lista de arrays. Podemos resolver este aviso especificando o genérico entre colchetes <>.

ArrayList<String> wordList = new ArrayList<>();

2.anotações de tipo

No Java 8Antes, os comentários podiam ser aplicados apenas às declarações. Agora, também podem ser usados comentários de tipo. Isso significa que podemos colocar anotações em qualquer lugar onde usamos o tipo.

chamada de construtor

new @Readonly ArrayList<>()

definição de tipo

@NonNull String str;

Esta declaração especifica uma variável não nula do tipo String str 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.

conversão de tipo

newStr = (@NonNull String) str;

cláusulas extends e implements

class Warning extends @Localized Message

throws cláusula

public String readMethod() throws @Localized IOException

Os comentários de tipo melhoram a análise do código Java e fornecem uma verificação de tipo mais robusta.

Annotation Types

1. Predefined Annotations

@Deprecated
@Override
@SuppressWarnings
@SafeVarargs
@FunctionalInterface

2. Meta Annotations

@Retention
@Documented
@Target
@Inherited
@Repeatable

3. Custom Annotations

These annotation types are inJava Annotation TypesDetailed description is available in the tutorial.

Annotation Usage

Compiler Instructions - Can be used to provide instructions to the compiler, detect errors, or suppress warnings. Such as built-in annotations @Deprecated, @Override, @SuppressWarnings.
Compile-time Instructions - These comments provide compile-time instructions that help software build tools generate code, XML files, etc.
Runtime Instructions - You can define some annotations to provide instructions to the program at runtime. These annotations are accessed using Java reflection.

Java Method Overloading Java try-with-resources