Entendendo Java Annotations – Tutorial Java @annotations

Publicados: 2019-10-22
Anotações no nível do pacote

Como e onde as anotações são usadas em Java?

Uma anotação, na linguagem de programação de computador Java, é uma forma especial de metadados sintáticos que podem ser adicionados ao código-fonte Java.

Classes, métodos, variáveis, parâmetros e pacotes podem ser anotados. Ao contrário das tags Javadoc, as anotações Java podem ser reflexivas, pois podem ser incorporadas em arquivos de classe gerados pelo compilador e podem ser retidas pela Java VM para serem recuperadas em tempo de execução.

É possível criar meta-anotações a partir das existentes em Java, o que torna este conceito mais sofisticado.

Java define um conjunto de anotações que são construídas na linguagem.

Entendendo as anotações Java - Dicas do Crunchify
Entendendo as anotações Java – Dicas do Crunchify

Anotações aplicadas ao código Java:

  • @Override – Verifica se a função é uma substituição. Causa um aviso de compilação se a função não for encontrada em uma das classes pai.
  • @Deprecated – Marca a função como obsoleta. Causa um aviso de compilação se a função for usada.
  • @SuppressWarnings – instrui o compilador a suprimir os avisos de tempo de compilação especificados nos parâmetros de anotação.

Anotações aplicadas a outras anotações:

  • @Retention – especifica como a anotação marcada é armazenada — seja apenas em código, compilada na classe ou disponível em tempo de execução por meio de reflexão.
  • @Documented – Marca outra anotação para inclusão na documentação.
  • @Target – Marca outra anotação para restringir a que tipo de elementos Java a anotação pode ser aplicada.
  • @Inherited – Marca outra anotação a ser herdada para as subclasses da classe anotada (por padrão, as anotações não são herdadas para as subclasses).

Vamos dar uma olhada nesses exemplos de exemplos:

1) @Override Anotação:

Sua presença indica ao compilador que o método anotado deve substituir um método de superclasse existente.

O caso de uso mais comum para @Override é com métodos Object :

1
2
3
4
@ Override
public int hashValue ( ) {
     System . out . Println ( "This method is using @Override Annotation" ) ;
}

A principal razão pela qual o @Override foi criado foi para lidar com erros tipográficos simples.

Por exemplo, um método declarado erroneamente como

1
public int hashvalue ( ) { . . . }

na verdade não é uma substituição – o nome do método tem todas as letras minúsculas, então não corresponde exatamente ao nome do método hashValue() . No entanto, ele compilará perfeitamente bem. Tal erro é fácil de cometer e difícil de detectar, o que é uma combinação perigosa. Usar a anotação @Override evita que você cometa esses erros.

Você deve ter o hábito de usar @Override sempre que substituir um método de superclasse.

Entendendo as anotações Java

2) @anotação obsoleta:

Esta anotação indica que o elemento marcado está obsoleto e não deve mais ser usado. O compilador gera um aviso sempre que um programa usa um método, classe ou campo com a anotação @Deprecated .

Quando um elemento é descontinuado, ele também deve ser documentado usando a tag Javadoc @deprecated , conforme mostrado no exemplo a seguir.

1
2
3
4
< strong > @ Deprecated < / strong >
static void deprecatedMethod ( ) {
     System . out . Println ( "This method is Deprecated.." ) ;
}

3) Anotação @SuppressWarnings:

Apenas diga ao compilador, por favor, não grite. Eu sei o que estou fazendo .

1
2
3
4
@ SuppressWarnings ( "serial" )
public class OldCode implements Serializable {
System . out . Println ( "This is Old Code.." ) ;
}

4) @Anotação de retenção:

A anotação de retenção indica onde e por quanto tempo as anotações com esse tipo devem ser retidas.

Existem três valores:

  • RetentionPolicy.SOURCE — As anotações com esse tipo serão retidas apenas no nível de origem e serão ignoradas pelo compilador.
  • RetentionPolicy.CLASS — As anotações com esse tipo serão retidas pelo compilador em tempo de compilação, mas serão ignoradas pela VM.
  • RetentionPolicy.RUNTIME — As anotações com esse tipo serão retidas pela VM para que possam ser lidas somente em tempo de execução.
1
2
3
4
@ Retention ( RetentionPolicy . RUNTIME )
public @ interface Crunchify_Retention {
   String returnSomething ( ) ;
}

5) @Anotação Documentada:

1
2
3
4
@ Documented
public @ interface Crunchify_Documented {
   String writeDocument ( ) ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DocumentedAnnotations {
   public static void main ( String arg [ ] ) {
       new DocumentedAnnotations ( ) . performRetention ( ) ;
       new DocumentedAnnotations ( ) . performDocumented ( ) ;
   }
   @ Crunchify_Retention ( returnSomething = "Hello retention test" )
   public void performRetention ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Retention'" ) ;
   }
   @ Crunchify_Documented ( writeDocument = "Hello document" )
   public void performDocumented ( ) {
       System . out . printf ( "Testing annotation 'Crunchify_Documented'" ) ;
   }
}

Agora tente executar o comando Java Doc e veja a saída.

6) Anotação @Target:

O destino indica quais elementos do programa podem ser anotados usando instâncias do tipo de anotação anotada. O valor de Target é um dos membros da enumeração java.lang.annotation.ElementType :

  1. ANNOTATION_TYPE. O tipo de anotação anotado pode ser usado para anotar a declaração do tipo de anotação.
  2. CONSTRUTOR. O tipo de anotação anotado pode ser usado para anotar a declaração do construtor.
  3. CAMPO. O tipo de anotação anotado pode ser usado para anotar a declaração do campo.
  4. LOCAL_VARIABLE. O tipo de anotação anotado pode ser usado para anotar a declaração da variável local.
  5. MÉTODO. O tipo de anotação anotado pode ser usado para anotar a declaração do método.
  6. PACOTE. O tipo de anotação anotado pode ser usado para anotar declarações de pacote.
  7. PARÂMETRO. O tipo de anotação anotado pode ser usado para anotar declarações de parâmetros.
  8. TIPO. O tipo de anotação anotado pode ser usado para anotar declarações de tipo.
1
2
3
4
@ Target ( value = METHOD )
You can have multiple values in the Target annotation .
 
@ Target ( value = { TYPE , FIELD , METHOD , PARAMETER , CONSTRUCTOR , LOCAL_VARIABLE } )

7) @Anotação Herdada:

Exatamente como o nome soa, um tipo de anotação @Inherited é herdado por subclasses de um tipo anotado.

1
2
3
4
5
6
7
8
9
10
@ Inherited
@ interface ForEveryone { }
 
@ interface JustForMe { }
 
@ ForEveryone
@ JustForMe
class Superclass { }
 
class Subclass extends Superclass { }

Neste exemplo, a Superclass foi explicitamente anotada com @ForEveryone e @JustForMe . A Subclass não foi explicitamente marcada com nenhum deles; no entanto, ele herda @ForEveryone porque o último é anotado com @Inherited .

@JustForMe não é anotado, portanto, não é herdado por Subclass .

Aqui está uma anotação de nível de classe

Anotações de nível de classe