O sistema de anotações foi adicionado no Java 5 e permite a adição de informações úteis sobre o nosso código sem afectarem o código a que se referem. No entanto, não afectando o código podem ser usadas de forma a produzirem acções relacionadas com o código.

As anotações, como o nome indica, servem para dar informações extra que podem depois ser usadas por ferramentas especializadas e automatizar tarefas, fornecer optimizações, geração automática de código, etc.

Tipicamente, podemos usar anotações para:

• Fornecer informação ao compilador - As anotações permitem indicar ao compilar como lidar com erros ou avisos, por exemplo suprimir mensagens de erro ou indicando relações de herança ou redefinição de métodos;
• Fornecer informações a ferramentas de compilação e de instalação - Muito usado por IDEs ou por ferramentas de domínios específicos com ORM, as anotações permite descrever o código de modo a que estas ferramentas possam gerar ficheiros XML, ficheiros para interfaces gráficas, configurações automáticas, etc;
• Processamento em tempo de execução - Algumas anotações oferecem informações específicas que são depois usadas pelo interpretador durante a execução das aplicações.

Na sua forma mais simples, a sintaxe de uma anotação é composta por um arroba (@) seguido do nome da anotação. A sintaxe completa contempla o nome da anotação seguido de parêntesis com os parâmetros a passar à anotação. As anotações podem ser colocadas antes dos atributos que afectam, da declaração dos métodos ou da declaração das classes.

@Author(
   name = "Benjamin Franklin",
   date = "27/03/2003"
)
class MClass() { }

Caso só exista um parâmetro a passar à anotação, o nome do parâmetro pode ser omitido. Caso não existam parâmetros, apenas o nome da anotação é necessário.

@Author("Benjamin Franklin")
class MClass() { }

@Override
void metodoRedefinido() { }

A estrutura das anotações é similar à estrutura de uma interface, parte da construção usa a palavra reservada interface com o arroba (@) antes. No que toca à plataforma, as anotações são, na verdade, um tipo específico de interface.

O bloco da anotação vai conter o código, com a definição dos elementos.

@interface DescricaoClasse {
    String autor();
    String data();
    int revisao() default 1;
    String ultimaModificacao() default "N/D";
    String modificadoPor() default "N/A";
    String[] revisores();  //<-- Uso de um array
}

Para podermos usar a anotação definida acima, precisaríamos colocar a anotação antes da declaração de uma classe.

@ClassPreamble (
    autor = "Knitter",
    data = "29/05/2010",
    revisao = 6,
    ultimaModificacao = "29/05/2010",
    modificadoPor = "Knitter",
    revisores = {"Alice", "Bob", "Cindy"} //<-- Uso do array
)
public class MClass extends MClassPai {
//...
}

• @Deprecated - Indica que determinado elemento de código irá ser marcado como deprecated e que irá forçar o compilador a emitir erros durante a compilação de código que faça uso destes elementos;
• @Override - Informa o compilador que o elemento afectado redefine um elemento de uma super-classe. Aplica-se na redefinição de métodos que existam nas super-classes de modo a facilitar a detecção de erros.
• @SuppressWarnings Esta anotação permite suprimir os erros que o compilador possa emitir. Aceita como parâmetro o tipo de erro a suprimir. O tipo de erros que é possível suprimir poderá ser dependente do compilador.

Embora o uso típico de anotações tenha como objectivo informar outras ferramentas de alguma particularidade do nosso código, poderá ser necessário criar um parser de anotações e ter acesso à informação das anotações durante a execução da aplicação. A forma exacta de o fazer não será abordada nesta página, mas fica a nota de que qualquer anotação que precise ter as suas informações visíveis durante a execução da aplicação deve definir uma política de retenção com o valor "Runtime".

import java.lang.annotation.*; 
 
@Retention(RetentionPolicy.RUNTIME)
@interface Anotacao {
    //...
}

<< Wrappers de Tipos Primitivos :: Início :: Genéricos >>