Programação
 › Algoritmo  › C/C++  › Java
Web
 › HTML/XHTML  › JavaScript  › PHP
Sistema Operacional
 › Comandos de DOS  › Windows  › Linux  › Mac/BSD
Office
 › Word / Writer  › Excel / Calc
Áreas do Site
 › Download  › Fórum  › Blog
Recomendamos
Computadores e Informática em Lisboa
TI Expert » Programação » Java » Annotations

Annotations

Annotations, traduzindo, quer dizer anotações.

Annotations dão informações sobre o código que está sendo escrito ou até mesmo do próprio programa, o que se assemelha aos comentários. Porém, annotations podem ser usados como objeto semântico de compiladores, ou seja, compiladores podem interpretar as annotations.

Dessa forma é possível que compiladores entendam que, por exemplo, não é para mostrar mensagens de advertências (Warnings), ou usar as annotations para detectar erros de código, criar documentações usando XML, etc.

Annotations podem possui elementos ou não. Seus elementos são sempre pair values, ou seja, elemento tem um nome e um valor.

Uso de Annotations

As annotations são sempre precedidas de arroba (@).

Por convenção, usamos annotations antes de um elemento qualquer, por exemplo, antes da criação de uma classe ou do uso de um método.

Existem annotations com vários pair values (valores diferentes) que são separados por vírgula, que contenham apenas um valor ou simplesmente nenhum valor. Exemplo: @SuppressWarnings(value = "unchecked").

Quando uma annotation possui apenas um elemento chamado value, então, apenas é necessário atribuir seu valor sem declarar o nome value. Exemplo: @SuppressWarnings("unchecked").

Quando uma annotation não possui elementos, não é necessário usar os parênteses. Exemplo: @Override.

Abaixo está uma lista com algumas das annotations mais utilizadas.

  • @Deprecated: Sempre que algum método tem seu uso desencorajado por ser perigoso ou por ter uma alternativa melhor desenvolvida, então, ele recebe a anotação @Deprecated.
  • @Override: Usado principalmente em casos de polimorfismo, sempre que formos sobrescrever um método da classe-pai (superclasse) devemos indicar ao compilador com @Override. Mas, devemos tomar cuidado ao utilizar @Override, pois se marcarmos o método e ele não sobrescrever nenhum método da classe-pai (superclasse), então, o compilador gerará uma mensagem erro.
  • @SuppressWarnings ("deprecation"): Todos os avisos da categoria "inadequado" são ignorados.
  • @SuppressWarnings ("unchecked"): Todos os avisos da categoria "não verificado" são ignorados.
  • @SuppressWarnings ({"unchecked", "deprecation"}): Todos os avisos de qualquer categoria são ignorados.

Criar uma Annotation

Antes de criarmos uma annotation, primeiramente temos que nos ater ao fato de que annotations apenas podem ser criadas em projetos que são compatíveis com JDK 5.0.

Annotations são criadas de forma muito parecida com interfaces, diferenciando pelo fato de antes da palavra-chave interface há um símbolo arroba (@), cada elemento se parece com a declaração de um método abstrato, a nomenclatura utilizada é a mesma utilizada para nomear Classes e cada annotation fica em um arquivo .java da mesma forma que uma classe, classe abstrata ou interface.

public @interface MinhaAnnotation {
    String elemento1();
    int elemento2();
}

Podemos definir um valor padrão para um elemento utilizando a palavra-chave default.

public @interface MinhaAnnotation {
    String elemento1() default "VALOR";
    int elemento2() default 123;
}

Também podemos utilizar vetores para a definição de um elemento.

public @interface MinhaAnnotation {
    String elemento1();        // elemento de String
    float elemento2();         // elemento de ponto flutuante
    int elemento3() default 1; // elemento inteiro que vale 1 por padrão
    String[] elemento4();      // elemento de VETOR de Strings
}

Abaixo está um exemplo de como usar nossa própria annotation.

public @interface DetalhesSoftware {
    String [] desenvolvedor ();
    String nomeProjeto ();
    String software ();
    float versao () default 1.0f;
}

Agora que temos nossa anotação, basta chamá-la.

@DetalhesSoftware (
    desenvolvedor = ("Desenvolvedor1", "Desenvolvedor2", "Desenvolvedor3"),
    nomeProjeto = "Java Resources Checker",
    software = "JRC",
    versao = 1.0f
)

public class AlgumaClasse {
    //código da classe
}

Adicionar Annotations ao Javadoc

Para fazer com que nossas annotations fiquem registradas no Javadoc toda vez que ele for gerado, devemos importar o pacote java.lang.annotation.Documented e antes de criarmos nossa annotation usarmos @Documented. Vejamos o exemplo abaixo:

import java.lang.annotation.Documented;

@Documented
public @interface DetalhesSoftware {
    String software ();
    String nomeProjeto ();
    float versao () default 1.0f;
    String [] desenvolvedor ();
}

Creative Commons License
Autor: Denys William Xavier
Este artigo está sob Licença Creative Commons.

Faça o download da versão em PDF Indique nosso site Gostou?
Indique nosso site!
Este artigo foi
lido 23921 vezes
Bookmark e Compartilhe

Páginas Relacionadas

Enquete
O Google Chrome OS irá desbancar o Microsoft Windows 7?
» ProgramaçãoAlgorítmo | C/C++ | Java

» WebHTML/XHTML | JavaScript | PHP

» Sistema OperacionalComandos de DOS | Windows | Linux | Mac/BSD

» OfficeWord/Wirter | Excel/Calc

» Áreas do SiteDownloads | Fórum | Blog