Anotações em Java: Tipos, Usos e Exemplos

Uma anotação em uma linguagem de programação como Java refere-se aos metadados sintáticos que podem ser integrados ao código-fonte Java. Vários fatores como pacotes Java, variáveis, classes, parâmetros e métodos podem ser anotados. Os desenvolvedores podem ler facilmente as anotações Java diretamente dos arquivos de origem, assim como as tags Javadoc.

As anotações Java também podem ser incluídas e lidas nos arquivos de classe Java de saída do compilador Java. Isso permite que a máquina virtual Java mantenha anotações e as leia por meio de uma reflexão em tempo de execução. Em Java, é possível construir meta-anotações a partir das já existentes.

Estes são alguns conceitos básicos de anotações em Java:

1. As anotações sempre começam com um '@'. Por exemplo: '@override', '@target', '@SuppressWarnings', etc.
2. As anotações não afetam o comportamento de um programa compilado.
3. As anotações ajudam a associar metadados a componentes do programa, como métodos, classes, variáveis, etc.
4. As anotações não são apenas comentários, pois podem afetar como um programa é processado pelo compilador. Eles oferecem informações adicionais do compilador sobre o programa, mas não fazem parte do programa em si. Portanto, essas anotações não afetam a execução do programa compilado.

Tipos de anotações em Java

1. Anotações de valor único

As anotações de valor único permitem apenas uma forma abreviada, pois contêm apenas um membro. O membro deve receber um valor após a aplicação da anotação. No entanto, o nome da anotação não precisa ser especificado. O membro deve ter um valor se a abreviação for usada. Por exemplo:

@TestAnnotation(“testando”);

2. Anotações completas

As anotações completas consistem em vários dados, como membros de dados, valores, pares e nomes.

Por exemplo:

@TestAnnotation(owner=”Rahul”, value=”Class Geeks”)

Aprenda cursos de desenvolvimento de software online das melhores universidades do mundo. Ganhe Programas PG Executivos, Programas de Certificado Avançado ou Programas de Mestrado para acelerar sua carreira.

3. Repetindo Anotações

Quando uma anotação pode ser aplicada a objetos singulares mais de uma vez, ela é rotulada como uma anotação de repetição. As anotações repetidas são especificadas com a tag @Repeatable conforme definido no pacote java.lang.annotation. Seu campo de valor indica o tipo de contêiner da anotação repetida.

O contêiner é definido como uma anotação com um campo de valor que contém uma matriz de anotações repetidas. Para construir uma anotação repetida, primeiro crie a anotação do contêiner e, em seguida, especifique o tipo de anotação como uma entrada para a anotação @Repeatable.

Por exemplo:

// Programa Java para Demonstrar uma Anotação Repetível

// Importando as classes necessárias

importar java.lang.annotation.Annotation;

import java.lang.annotation.Repeatable;

import java.lang.annotation.Retention;

importar java.lang.annotation.RetentionPolicy;

import java.lang.reflect.Method;

// Torna a anotação do Words repetível

@Retention(RetentionPolicy.RUNTIME)

@Repeatable(MyRepeatedAnnos.class)

@interface Palavras

{

String palavra() padrão “Olá”;

int valor() padrão 0;

}

// Cria a anotação do container

@Retention(RetentionPolicy.RUNTIME)

@interface MyRepeatedAnnos

{

Palavras[] valor();

}

classe pública Principal {

// Repetir palavras em newMethod

@Words(palavra = “Primeiro”, valor = 1)

@Words(palavra = “Segundo”, valor = 2)

public static void newMethod()

{

obj principal = new Principal();

tentar {

Classe<?> c = obj.getClass();

// Obtém a anotação para newMethod

Método m = c.getMethod(“newMethod”);

// Exibe a anotação repetida

Anotação de anotação

= m.getAnnotation(MyRepeatedAnnos.class);

System.out.println(ano);

}

catch (NoSuchMethodException e) {

System.out.println(e);

}

}

public static void main(String[] args) { newMethod(); }

}

A saída final seria: @MyRepeatedAnnos(value={@Words(value=1, word=”First”), @Words(value=2, word=”Second”)})

Explore nossos cursos populares de engenharia de software

3. Anotações do marcador

As anotações do marcador são apenas para fins de declaração. Nem esta anotação contém nenhum membro nem nenhum dado existe dentro dela. Seu único propósito é manter uma presença como uma anotação. Por exemplo: @Override.

4. Digite anotações

Essas anotações podem ser usadas em todos os lugares em que um tipo é usado. Por exemplo, podemos anotar o tipo de retorno de um método. As anotações de tipo são marcadas com a anotação @Target.

Os códigos que podem ilustrar as anotações de tipo são:

// Importando as classes necessárias

import java.lang.annotation.ElementType;

importar java.lang.annotation.Target;

// Usando anotação de destino para anotar um tipo

@Target(ElementType.TYPE_USE)

// Declarando uma anotação de tipo simples

@interface TypeAnnoDemo{}

// Classe principal

classe pública GFG {

// Método do driver principal

public static void main(String[] args) {

// Anotando o tipo de uma string

@TypeAnnoDemo String string = “Este código é anotado com uma anotação de tipo”;

System.out.println(string);

abc();

}

// Anotando o tipo de retorno de uma função

static @TypeAnnoDemo int abc() {

System.out.println(“O tipo de retorno desta função é anotado”);

retornar 0;

}

Exemplos de anotações predefinidas

Existem muitas variedades de anotações predefinidas que mencionamos anteriormente. Vamos dar uma olhada:

1. @Substituir

Esta anotação de marcador só pode ser usada em métodos. Qualquer método com a anotação @override deve substituir outro método de uma superclasse. Caso contrário, um erro em tempo de compilação é acionado. Isso acontece porque deve garantir que a superclasse seja realmente substituída e não apenas sobrecarregada.

O código que pode ilustrar a anotação de substituição é:

// Classe 1

base de classe

{

public void Exibir()

{

System.out.println(“Base display()”);

}

public static void main(String args[])

{

Base t1 = new Derivado();

t1.Exibir();

}

}

// Classe 2

// Estendendo acima da classe

classe Derivado estende Base

{

@Sobrepor

public void Exibir()

{

System.out.println(“Exibição derivada()”);

}

}

2. @Alvo

Destina-se apenas a ser usado como uma anotação para outra anotação. @Target aceita um parâmetro, que deve ser uma constante ElementType. O parâmetro decide a quais declarações ele pode ser aplicado. A anotação @Target pode ter vários valores em vez de apenas um valor singular. No entanto, se vários valores devem ser declarados, eles devem estar na forma de chaves, como: @Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE}).

A anotação @Retention pode ser usada aqui para determinar o status de retenção da anotação. Três fatores afetam uma anotação @Retention:

• Fonte: O compilador desconsidera as anotações, pois elas geralmente são mantidas no nível da fonte.
• Tempo de execução: é retido em tempo de execução.
• Classe: As anotações permanecem em tempo de compilação e são desconsideradas pelo programa Java.

3. @Herdado

Essa anotação só pode ser usada para fins de declaração e, portanto, afeta apenas determinadas declarações de classe. Uma anotação pode substituir a outra e herdar suas propriedades. Assim, a superclasse pode ser verificada se anotações específicas estiverem ausentes da subclasse. No entanto, se a anotação estiver presente, ela obtém a anotação @Inherited.

Por exemplo:

// Classe 1

classe obsoletaTest

{

@Descontinuada

public void Exibir()

{

System.out.println(“Teste de exibição obsoleto()”);

}

}

// Classe 2

classe pública SuprimirWarningTest

{

// Se comentarmos abaixo da anotação, o programa gera

// aviso

@SuppressWarnings({“verificado”, “suspensão”})

public static void main(String args[])

{

DeprecatedTest d1 = new DeprecatedTest();

d1.Exibir();

}

}

Conclusão

Aqui, aprendemos sobre anotações em Java. Também aprendemos sobre os tipos de anotações em Java e seus usos que podem ajudar os desenvolvedores Java a criar programas robustos e escaláveis ​​com facilidade.

Se você quiser aprender mais sobre os conceitos Java, a Certificação PG vinculada ao trabalho do upGrad em Engenharia de Software é sua melhor aposta para obter uma compreensão abrangente de linguagens de programação como Java, HTML, JS, bem como outras ferramentas e bibliotecas de desenvolvimento de software.

O programa é projetado para estudantes do último ano ou graduados desempregados que procuram garantir posições de nível de entrada no campo. O curso de 5 meses abrange a especialização em MERN/Cloud-Native e ajuda os alunos a criar um portfólio de primeira classe, expondo-os a 5 projetos práticos.

Então, não espere. Vá até o upGrad e reserve seu lugar hoje!