Java Anotação é uma tag que representa o metadados ou seja, anexado a classe, interface, métodos ou campos para indicar algumas informações adicionais que podem ser usadas pelo compilador java e JVM.

Anotações em Java são usadas para fornecer informações adicionais, portanto é uma opção alternativa para interfaces de marcadores XML e Java.

Primeiro, aprenderemos algumas anotações integradas e depois prosseguiremos criando e usando anotações personalizadas.

Anotações Java integradas

Existem várias anotações integradas em Java. Algumas anotações são aplicadas ao código Java e outras a outras anotações.

Anotações Java integradas usadas no código Java

• @Sobrepor
• @Suprimir avisos
• @Descontinuada

Anotações Java integradas usadas em outras anotações

• @Alvo
• @Retenção
• @Herdado
• @Documentado

Compreendendo as anotações integradas

Vamos entender as anotações integradas primeiro.

@Sobrepor

A anotação @Override garante que o método da subclasse esteja substituindo o método da classe pai. Caso contrário, ocorre um erro de tempo de compilação.

Às vezes, cometemos erros bobos, como erros de ortografia, etc. Portanto, é melhor marcar a anotação @Override que fornece garantia de que o método foi substituído.

SDLC

 class Animal{ void eatSomething(){System.out.println('eating something');} } class Dog extends Animal{ @Override void eatsomething(){System.out.println('eating foods');}//should be eatSomething } class TestAnnotation1{ public static void main(String args[]){ Animal a=new Dog(); a.eatSomething(); }} 

 Output:Comple Time Error 

@Suprimir avisos

Anotação @SuppressWarnings: é usada para suprimir avisos emitidos pelo compilador.

 import java.util.*; class TestAnnotation2{ @SuppressWarnings('unchecked') public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('sonoo'); list.add('vimal'); list.add('ratan'); for(Object obj:list) System.out.println(obj); }} 

 Now no warning at compile time. 

Se você remover a anotação @SuppressWarnings('unchecked'), ela mostrará um aviso em tempo de compilação porque estamos usando uma coleção não genérica.

@Descontinuada

A anoação @Deprecated marca que este método está obsoleto, então o compilador imprime um aviso. Informa ao usuário que poderá ser removido em versões futuras. Então, é melhor não usar tais métodos.

geração de números aleatórios java

 class A{ void m(){System.out.println('hello m');} @Deprecated void n(){System.out.println('hello n');} } class TestAnnotation3{ public static void main(String args[]){ A a=new A(); a.n(); }} 

Em tempo de compilação:

 Note: Test.java uses or overrides a deprecated API. <br> Note: Recompile with -Xlint:deprecation for details. 

Em tempo de execução:

 hello n 

Anotações personalizadas Java

Anotações personalizadas Java ou Java As anotações definidas pelo usuário são fáceis de criar e usar. O @interface elemento é usado para declarar uma anotação. Por exemplo:

 @interface MyAnnotation{} 

Aqui, MyAnnotation é o nome da anotação personalizada.

Pontos a serem lembrados para assinatura de anotação personalizada java

Existem alguns pontos que devem ser lembrados pelo programador.

1. O método não deve ter nenhuma cláusula throws
2. O método deve retornar um dos seguintes: tipos de dados primitivos, String, Classe, enum ou array desses tipos de dados.
3. O método não deve ter nenhum parâmetro.
4. Devemos anexar @ logo antes da palavra-chave da interface para definir a anotação.
5. Pode atribuir um valor padrão ao método.

Tipos de anotação

Existem três tipos de anotações.

1. Anotação de marcador
2. Anotação de valor único
3. Anotação de vários valores

1) Anotação do marcador

Uma anotação que não possui método é chamada de anotação de marcador. Por exemplo:

autômatos finitos determinísticos

 @interface MyAnnotation{} 

O @Override e @Deprecated são anotações de marcador.

2) Anotação de valor único

Uma anotação que possui um método é chamada de anotação de valor único. Por exemplo:

 @interface MyAnnotation{ int value(); } 

Também podemos fornecer o valor padrão. Por exemplo:

 @interface MyAnnotation{ int value() default 0; } 

Como aplicar anotação de valor único

Vamos ver o código para aplicar a anotação de valor único.

 @MyAnnotation(value=10) 

O valor pode ser qualquer coisa.

3) Anotação de múltiplos valores

Uma anotação que possui mais de um método é chamada de anotação Multi-Value. Por exemplo:

 @interface MyAnnotation{ int value1(); String value2(); String value3(); } } 

Também podemos fornecer o valor padrão. Por exemplo:

 @interface MyAnnotation{ int value1() default 1; String value2() default ''; String value3() default 'xyz'; } 

Como aplicar anotação de vários valores

Vamos ver o código para aplicar a anotação de vários valores.

 @MyAnnotation(value1=10,value2='Arun Kumar',value3='Ghaziabad') 

Anotações integradas usadas em anotações personalizadas em java

• @Alvo
• @Retenção
• @Herdado
• @Documentado

@Alvo

@Alvo tag é usada para especificar em qual tipo a anotação é usada.

O java.lang.annotation. ElementoTipo enum declara muitas constantes para especificar o tipo de elemento onde a anotação deve ser aplicada, como TYPE, METHOD, FIELD etc. Vamos ver as constantes de ElementType enum:

Exemplo para especificar anotação para uma classe

 @Target(ElementType.TYPE) @interface MyAnnotation{ int value1(); String value2(); } 

Exemplo para especificar anotação para uma classe, métodos ou campos

 @Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD}) @interface MyAnnotation{ int value1(); String value2(); } 

@Retenção

@Retenção anotação é usada para especificar em que nível a anotação estará disponível.

python é numérico

Exemplo para especificar a RetentionPolicy

 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface MyAnnotation{ int value1(); String value2(); } 

Exemplo de anotação personalizada: criação, aplicação e acesso à anotação

Vejamos o exemplo simples de criação, aplicação e acesso à anotação.

Arquivo: Teste.java

 //Creating annotation import java.lang.annotation.*; import java.lang.reflect.*; @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface MyAnnotation{ int value(); } //Applying annotation class Hello{ @MyAnnotation(value=10) public void sayHello(){System.out.println('hello annotation');} } //Accessing annotation class TestCustomAnnotation1{ public static void main(String args[])throws Exception{ Hello h=new Hello(); Method m=h.getClass().getMethod('sayHello'); MyAnnotation manno=m.getAnnotation(MyAnnotation.class); System.out.println('value is: '+manno.value()); }} 

 Output:value is: 10 

Como as anotações integradas são usadas no cenário real?

No cenário real, o programador Java só precisa aplicar a anotação. Ele/ela não precisa criar e acessar anotações. A criação e o acesso à anotação são realizados pelo provedor de implementação. Em nome da anotação, o compilador Java ou JVM executa algumas operações adicionais.

@Herdado

Por padrão, as anotações não são herdadas pelas subclasses. A anotação @Inherited marca a anotação a ser herdada para as subclasses.

 @Inherited @interface ForEveryone { }//Now it will be available to subclass also @interface ForEveryone { } class Superclass{} class Subclass extends Superclass{} 

@Documentado

O @Documented marca a anotação para inclusão na documentação.