anotação
1. O que é anotação? (Anotação ou comentários)
Anotação, a tradução precisa deve ser - anotação. É completamente diferente dos comentários.
Anotação é um recurso introduzido pelo JDK5.0 e versões posteriores. Está no mesmo nível das classes, interfaces e enumerações e pode se tornar um tipo de java.
A sintaxe começa com @,
Comentários são algumas memorização ou descrições rápidas feitas por programadores das classes de código -fonte, métodos, propriedades etc. (como para que esse método é usado) e que as pessoas vejam.
A anotação é a parte que o compilador Java pode entender e é para o compilador ver.
Vamos dar um exemplo simples para ver o uso e a função das anotações.
@Override é uma anotação comum de Java. Sua função é verificar se os métodos definidos na subclasse estão corretos ao compilar o código.
anotação do pacote; Classe abstrata pública Animal {public abstract void Eat (); } anotação do pacote; public class Cat estende Animal {@Override public void Eat (String Food) {}} Aqui, na subclasse gato, o método Eat é anotado como um método que substitui a classe pai, mas possui mais um parâmetro que o método da classe pai.
Se você estiver editando no Eclipse, haverá um prompt da Cruz Vermelha. (A compilação de código não será passada).
Se você remover a anotação @Override, não há problema na compilação, mas o método Eat in Cat é um novo método dessa classe, não herdado da classe pai.
2. Anotações incorporadas de java comum
Incluindo @Override, que outras anotações comuns de Java?
1. @Deprecated
A anotação não é recomendada e pode ser usada em métodos e classes.
Basicamente, esse método e classe são abandonados e não recomendados por alguns motivos, como atualização ou desempenho, mas devem ser retidos para compatibilidade ou outros motivos.
Então coloque esta anotação nele.
Existem muitos exemplos na própria API Java. Se você colocar essa anotação no método, verá qual novo método alternativo é.
Ao escrever o código no Eclipse, o método que adiciona essa anotação adicionará striketroughs à declaração e à chamada.
2.@substituir
3.@Suppresswarnings
Ignorar avisos.
Se o seu código tiver alguns avisos em transformação ou outras partes, mas você deseja ignorar esses avisos, poderá usar esta anotação.
1) Aviso quando a depreciação usa uma classe ou método que não é favorecido
2) Aviso desmarcado quando a conversão desmarcada é realizada
3) Os avisos de queda aparecem quando a operação de quebra não é adicionada após o uso do caso, fazendo com que o programa continue a executar outras instruções de caso
4) Aviso de caminho ao definir um caminho de classe incorreto ou caminho de arquivo de origem
5) Aviso em série quando falta a definição serialversionUid na classe serializável
6) Aviso noivado se alguma cláusula finalmente não puder ser concluída normalmente
7) Todos os avisos sobre todas as situações acima
3. Anotações personalizadas
Além das anotações internas fornecidas pelo próprio Java, o Java também fornece a função de personalizar anotações personalizadas.
A maneira de definir anotações é usar anotações para definir anotações. As anotações usadas para definir anotações são chamadas de meta -anotações.
As principais anotações são as seguintes: @target; @Retenção; @Documented; @Irited
1. @Target indica onde a anotação é usada e pode ser usada em classes, métodos ou atributos. Os possíveis parâmetros ElemetType incluem:
Declaração do construtor Elemenettype.Constructor
Declaração de domínio Elemenettype.field (incluindo instâncias de enum)
Elemenettype.local_variable Declaração de variável local
Declaração do método Elemenettype.Method
Declaração do pacote Elemenettype.package
Declaração de parâmetro Elemenettype.parameter
Elemenettype.Type Class, interface (incluindo tipo de anotação) ou declaração de enum
2. @Retention indica em que nível salvar as informações de anotação. Os parâmetros opcionais de retenção de políticas incluem:
RetentionPolicy.Source Anotation será descartada pelo compilador
RetentionPolicy.Class Anotation está disponível no arquivo de classe, mas será descartada pela VM.
RetentionPolicy.Runtime VM também manterá comentários durante o tempo de execução, para que as informações de anotação possam ser lidas através do mecanismo de reflexão.
3. @Documented, seja incluindo esta anotação ao gerar documentos, inclua esta anotação no Javadoc
4. @Irited
Deixe as subclasses herdar as anotações na classe pai, veja alguns exemplos simples de definição:
anotação do pacote; importar java.lang.annotation.Documented; importar java.lang.annotation.ElementType; importar java.lang.annotation.Irited; importar java.lang.annotation.retention; importar java.lang.annotation.retEntionPolicy; importar java.lang.annotation.target; @Target (elementType.method) public @Interface myannotation {string value (); } @Retention (retentionPolicy.source) @Interface myannotation1 {} @retention (retentionpolicy.class) @interface myannotation2 {} @retention (retentionPolicy.Runtime) @Interface myannotation3 {} @Documented4. Use exemplos:
anotação do pacote; importar java.lang.annotation.annotation; @Myannotation3 classe pública testannotation {public static void main (string [] args) {// TODO Método Auto-Gerado Anotação de Anotação do Método = testannotation.class.getAnnotation (myannotation3.class); System.out.println (anotação.toString ()); }} Imprima o resultado: @annotation.myannotation3 ()
Se myannotation1 e myannotation2 forem substituídos no exemplo acima, o valor da anotação obtido está vazio, que é a diferença entre a policéia de retenção.
V. O papel da anotação
Nesse ponto, podemos resumir o papel da anotação.
O básico pode ser dividido em três categorias:
1. Escreva um documento
2. Análise de código
3. Verificação de compilação No entanto, as estruturas de código aberto oferecem mais funções, como:
Hibernate, configuração de anotação,
@Column ("aa") private string xx; Isso é semelhante à configuração XML, que simplifica a configuração no programa e move uma parte dos metadados do arquivo XML para o próprio código, e o gerencia e o mantém em um só lugar.
Como é implementado internamente? - Mecanismo de reflexão Java, semelhante ao exemplo acima.
Comentários
Embora as anotações e comentários sejam apenas uma palavra diferente, o uso é muito diferente.
A mesma frase é verdadeira, as anotações são para o compilador ver, e as anotações são para as pessoas verem.
Com base nisso, para um método:
1. Apenas descreva a função desse método claramente, entrada e saída. Você pode adicionar mais informações, como autores e versões.
2. Basta fazer essas duas coisas com um lindo arranjo de comentários. Por exemplo:
/************************************************* *************************************************
Parece que esta é uma boa nota ^^.
Mas, para a linguagem Java, os comentários recebem mais funções. Ou seja, você pode usar a função javadoc para exportar comentários no código para o arquivo HTML.
Se o seu código for de código com alta semelhança, este documento será um documento de referência da API, semelhante à API Java.
Portanto, para gerar esse documento, você deve seguir algumas especificações de anotação definidas pelo Java para produzir um documento padronizado.
1. Comentários padrão sobre métodos de classe Java
Vamos começar com os comentários sobre o método da classe.
/*** Leia uma linha de texto. Uma linha é considerada rescindida por qualquer um * de um feed de linha ('/n'), um retorno de carruagem ('/r') ou um retorno de carruagem * seguido imediatamente por um alinhamento. * * @param ignorelf1 Se verdadeiro, o próximo '/n' será ignorado <pré -code_snippet_id = "74911" snippet_file_name = "blog_20131120_2_8365599" name = "code"> * @param Ignorelf2 se true, o próximo '/n', será Qualquer caractere de terminação de linha, ou nulo se o final do * fluxo foi alcançado * * @see java.io.LineNumberReader#readLine () * * @Exception IoException Se ocorrer um erro de E/S */ (Não preste atenção ao significado dos comentários acima, basta concentrar -se no estilo de sua definição)
1. Primeiro olhe para o topo "Leia uma linha de texto. Uma linha ..". Este parágrafo é uma descrição desse método.
A parte antes do primeiro período, que é "Leia uma linha de texto". aparecerá em "Resumo do método"
2. @Param define os parâmetros de entrada do método, que (o múltiplo pode ser adicionado) aparece em "Detalhes do método". (O parâmetro e a descrição do parâmetro são separados por espaços e convertidos em - no documento gerado)
3. @Return Descrição do valor de retorno
4. @See Referência Descrição
5. A descrição da @Exception lançada pela exceção é linda. Diferentes tipos de tags podem ser exibidos em uma linha, como @param e @return, esvazie diretamente uma linha.
2. Comentários padrão da classe Java
O formato das anotações de classe e anotações de método é basicamente o mesmo. Qual é a diferença:
1. A colocação é diferente. As anotações de classe são colocadas acima da definição de classe e as anotações de método são colocadas acima da definição do método.
2. Comparação de anotação de classe usa tags como @version @author @since.
Olhe para o modelo
/** Bufferá a entrada do arquivo especificado. Sem buffer, cada * invocação de read () ou readLine () pode fazer com que os bytes sejam lidos no arquivo *, convertidos em caracteres e depois retornados, o que pode ser muito * inerente. * * Descrição do teste * * <p> Programas que usam DataInputStreams para entrada textual podem ser localizados * substituindo cada DataInputStream por um leitor de buffers apropriado. * * @See FileReader * @see inputStreamReader * * @version 0.1, 20/11/13 * @Author Oscar999 * @since jdk1.5 */
Os efeitos exibidos no DOC são:
Da mesma forma, a primeira frase da descrição aparece no "Classário".
Os detalhes da classe são exibidos da seguinte forma:
Vale a pena notar que o uso de <p> na descrição. Se <p> não for adicionado, não importa se existe uma nova linha no código Java, o documento gerado não será novo. Se <p> for adicionado, uma nova linha aparecerá no doc.
3. Suplemento
Para acrescentar, o método para gerar javadoc:
1. Método de linha nomeado: Javadoc + Parâmetros
2. Use o IDE do Eclipse para exportar se, no Eclipse IDE, clique com o botão direito do mouse no arquivo ou projeto de origem, selecione Exportar --->
Java -> Javadoc pode ser gerado.