Símbolo de anotação @ em Java
Este artigo apresentará o símbolo @, que é chamado de anotações em Java. Vamos nos concentrar em anotações Java integradas como @Override, @SuppressWarnings e @Deprecated.
a anotação @Override em Java
A anotação é uma forma de indicar as informações extras anexadas a uma classe, interface e método em Java. O compilador Java e a JVM usam as informações fornecidas com o uso de anotações. Uma anotação começa com o símbolo @. A anotação @Override garante que o método da classe filha substitua o método da classe pai. É uma anotação de marcador porque não possui nenhum valor ou elemento. Quando usamos a anotação @Override, o compilador irá gerar erros e nos avisar se houver algum erro ao sobrescrever o método. Os prováveis erros que verifica são os erros ortográficos e os erros de argumento e tipo de retorno. Podemos demonstrar o uso da anotação @Override criando uma herança. Em primeiro lugar, não vamos usar a anotação, mas depois vamos usá-la para demonstrar como funciona @Override.
Por exemplo, crie uma classe Parent e escreva um método message() com um tipo de retorno void. Imprima algumas mensagens dentro do método. Da mesma forma, crie outra classe, Child, e estenda a classe Parent. Crie o mesmo método mensagem com o tipo void e escreva uma mensagem dentro dele. Antes do método, escreva a anotação @Override. Então, dentro da classe principal, crie objetos de cada uma das classes e chame o método message().
Aqui, a subclasse herda a superclasse e cada um dos métodos em cada classe é invocado sem nenhum problema.
Código de exemplo:
class Annotation {
public static void main(String[] args) {
new Child().message();
new Parent().message();
}
}
class Parent {
void message() {
System.out.println("Invoked from the Parent class");
}
}
class Child extends Parent {
@Override
void message() {
System.out.println("Invoked from the Child class");
}
}
Produção:
Invoked from the Child class
Invoked from the Parent class
Modifique o método message() na classe Child para mesage(). Em seguida, execute o programa. Ele mostra a seguinte saída.
Produção:
Annotation.java:18: error: method does not override or implement a method from a supertype
Aqui, mudamos o nome do método. Às vezes, o programador pode cometer esses tipos de erros enquanto os substitui. Assim, a anotação @Override garante qualquer erro enquanto sobrescreve um método e alerta o programador.
a anotação @SuppressWarnings em Java
A anotação @SuppressWarnings diz ao compilador para suprimir ou ignorar o erro para a parte especificada do código. Podemos usar a anotação para um tipo, campo, método, parâmetro, construtor e variável local. Podemos especificar o valor unchecked entre os parênteses da anotação como @SuppressWarnings("unchecked") para suprimir o erro. Quando usamos a anotação antes da classe, ela suprime quaisquer erros dentro da classe. E quando o usamos antes de qualquer método dentro de uma classe, ele apenas suprimirá o erro daquela classe em particular.
Por exemplo, importe o pacote util e crie uma classe chamada Annotation. Escreva @SuppressWarnings("unchecked") antes do método main. Dentro do método main, crie uma instância de ArrayList() e atribua-a à variável fruits. Em seguida, adicione os valores apple e mango com o método add(). Finalmente, imprima a variável fruits.
No exemplo abaixo, importamos tudo do pacote util. Ele importa a classe ArrayList que usaremos posteriormente. O código acima é executado com sucesso, embora haja um erro. Usamos a coleção não genérica ArrayList. Não especificamos o tipo dentro de um símbolo <>. Portanto, o código está com defeito. Mas é executado porque suprimimos o erro usando a anotação @SuppressWarnings.
Código de exemplo:
import java.util.*;
class Annotation {
@SuppressWarnings("unchecked")
public static void main(String args[]) {
ArrayList fruits = new ArrayList();
fruits.add("apple");
fruits.add("mango");
System.out.println(fruits);
}
}
Produção:
[apple, mango]
Se não usarmos a anotação para o código a seguir, o compilador mostrará o seguinte erro.
Produção:
Note: Annotation.java uses unchecked or unsafe operations.
a anotação @Deprecated em Java
A anotação @Deprecated é usada para denotar o trecho de código especificado como código obsoleto. O compilador mostrará um aviso de depreciação quando usarmos a anotação. Podemos anotar um tipo, método, campo e construtor usando a anotação @Deprecated.
Por exemplo, crie uma classe Car e crie um construtor com os parâmetros color, length e width. Use a anotação @Deprecated antes do construtor. Deixe o corpo vazio. Crie outro construtor e escreva nele um parâmetro de string name. Crie outra classe, Annotation, e dentro do método main, chame esses dois construtores.
No exemplo abaixo, usamos as anotações @Deprecated antes do primeiro construtor. Ele permite que o compilador gere um aviso informando que o construtor está obsoleto. Dessa forma, podemos usar a anotação para especificar algo que está obsoleto no código. A remoção do código obsoleto não é incentivada porque pode ser usada para reverter para versões anteriores, se necessário. A nova alternativa é encorajada a ser usada nesses casos.
Código de exemplo:
class Annotation {
public static void main(String args[]) {
new Car("red", 550, 300);
new Car("Lambo");
}
}
class Car {
@Deprecated
Car(String color, int length, int width) {}
Car(String name) {}
}
Produção:
Note: Annotation.java uses or overrides a deprecated API.