Anotações Java

Qual é a finalidade das anotações em Java? Eu tenho essa ideia difusa deles como algo entre um comentário e um código real. Eles afetam o programa em tempo de execução?

Quais são seus usos típicos?

Eles são exclusivos do Java? Existe um equivalente em C ++?

As anotações são usadas principalmente por código que inspeciona outro código. Eles são freqüentemente usados ​​para modificar (ou seja, decorar ou embrulhar) classes existentes em tempo de execução para alterar seu comportamento. Frameworks como JUnit e Hibernate usam anotações para minimizar a quantidade de código que você precisa escrever para usar os frameworks.

A Oracle tem uma boa explicação do conceito e seu significado em Java em seu site.

Além disso, eles são exclusivos do Java, há um equivalente em C ++?

Não, mas VB e C # têm atributos que são a mesma coisa.

Seu uso é bastante diversificado. Um exemplo típico de Java @Overridenão tem efeito sobre o código, mas pode ser usado pelo compilador para gerar um aviso (ou erro) se o método decorado não substituir outro método. Da mesma forma, os métodos podem ser marcados como obsoletos.

Então há reflexão. Ao refletir um tipo de classe em seu código, você pode acessar os atributos e agir de acordo com as informações ali encontradas. Não conheço nenhum exemplo em Java, mas no .NET isso é usado pelo compilador para gerar informações de (des) serialização para classes, determinar o layout de memória de estruturas e declarar importações de função de bibliotecas legadas (entre outras). Eles também controlam como o designer de formulário IDE funciona.

/ EDIT: Atributos em classes são comparáveis ​​a interfaces de tag (como Serializable em Java). No entanto, as diretrizes de codificação .NET dizem para não usar interfaces de tag. Além disso, eles só funcionam no nível da classe, não no nível do método.

Anders fornece um bom resumo, e aqui está um exemplo de uma anotação JUnit

@Test(expected=IOException.class)
public void flatfileMissing() throws IOException {
    readFlatFile("testfiles"+separator+"flatfile_doesnotexist.dat");
}

Aqui, a @Testanotação está dizendo ao JUnit que o flatfileMissingmétodo é um teste que deve ser executado e que o resultado esperado é lançado IOException. Portanto, quando você executa seus testes, este método será chamado e o teste será aprovado ou reprovado com base em se um IOExceptioné lançado.

Java também tem a Annotation Processing Tool (apt), onde não apenas você cria anotações, mas também decide como essas anotações funcionam no código-fonte.

Aqui está uma introdução.

Para ver algumas coisas legais que você pode fazer com Anotações, verifique minhas anotações JavaBean e processador de anotações .

Eles são ótimos para gerar código, adicionar validações extras durante sua construção, e também os tenho usado para uma estrutura de mensagem de erro (ainda não publicada - preciso esclarecer com os chefes ...).

Por definição literal, uma anotação adiciona notas a um elemento. Da mesma forma, as anotações Java são tags que inserimos no código-fonte para fornecer mais informações sobre o código. As anotações Java associam informações ao elemento de programa anotado. Além das anotações Java, os programas Java possuem uma grande quantidade de documentação informal que normalmente está contida nos comentários do arquivo de código-fonte. Mas, as anotações Java são diferentes dos comentários, elas anotam os elementos do programa diretamente usando tipos de anotação para descrever a forma das anotações. As anotações Java apresentam as informações de uma forma padronizada e estruturada para que possam ser utilizadas de forma cómoda por ferramentas de processamento.

Para ler em detalhes, há um bom tutorial sobre anotações Java

Quando você usa a anotação @Override do Java e por quê? O link refere-se a uma pergunta sobre quando se deve usar a anotação de substituição (@override). Isso pode ajudar a entender melhor o conceito de anotação.

Anotações quando se trata de EJB são conhecidas como a escolha da abordagem de middleware implícito em vez de uma abordagem de middleware explícita. Quando você usa anotação, está personalizando o que exatamente precisa da API, por exemplo, você precisa chamar o método de transação para uma transferência bancária : sem usar anotação: o código será

transfer(Account account1, Account account2, long amount)    
{
   // 1: Call middleware API to perform a security check
   // 2: Call middleware API to start a transaction
   // 3: Call middleware API to load rows from the database
   // 4: Subtract the balance from one account, add to the other
   // 5: Call middleware API to store rows in the database
   // 6: Call middleware API to end the transaction
}

enquanto usa o Annotation, seu código não contém chamadas de API complicadas para usar os serviços de middleware. O código é limpo e focado na lógica de negócios

transfer(Account account1, Account account2, long amount) 
{
   // 1: Subtract the balance from one account, add to the other
}