Visão geral
Java introduziu a anotação na versão 1.5, também conhecida como Anotação Java. A anotação é um tipo de metadados de sintaxe que pode ser usada diretamente no código -fonte, e as classes/métodos/variáveis/parâmetros/nomes de pacotes, etc. podem ser anotados. Ao contrário das tags Javadoc, o compilador pode reter o código de anotação ao gerar o arquivo de classe. Ao mesmo tempo, para usar anotações durante o processo de tempo de execução, a máquina virtual Java mantém a anotação, de modo que as informações relevantes sobre a anotação possam ser obtidas através da reflexão.
Anotações internas
De fato, geralmente encontramos anotações, como @Override, @Deprecated, etc. Essas são todas as anotações internas no JDK. Vamos primeiro dar uma olhada em quais são as principais anotações internas em Java.
• Anotações que agem no código Java
◦@Substitua verifica se um método é um método de reescrita. Se esse método não for encontrado na classe pai ou na interface implementada, ocorrerá um erro de compilação.
@@Marcas depreciadas que um método ou classe é descartado. Se a classe ou método for usado, o processo de compilação o alertará.
◦@supressornings notifique o compilador para ignorar os avisos sobre os parâmetros anotados
@@Safevarargs Ignore avisos sobre os métodos de chamada ou construtores contendo parâmetros genéricos, 1.7 adicionou anotações
◦@funcionalInterface indica que uma interface declarada será usada como uma interface funcional. 1.8 adicionou anotação
• Anotações feitas em outras anotações são chamadas de meta -anotações (meta anotação)
◦@Retenção Especifica quando a anotação anotada é usada (ou seja, quando a anotação será retida)
■ Retenção apenas no código -fonte e descartado durante a compilação (retentionpolicy.runtime)
■ As anotações são salvas no arquivo de classe durante a compilação e são ignoradas quando o arquivo de classe é carregado (retentionpolicy.class)
■ As anotações são lidas quando o arquivo de classe é carregado, ou seja, as anotações estão disponíveis durante a operação. As anotações podem ser obtidas através da reflexão (retençãopolicy.runtime)
◦@documentado indica que, ao gerar Javadoc, as anotações anotadas serão gravadas no documento Javadoc.
@@Target Especifica o escopo da anotação anotada ■ ElementType.Type: Usado para descrever uma classe, interface (incluindo tipo de anotação) ou Declaração de Enum ■ ElementType.Field: Usado para descrever o domínio ■ elementType.Method: Usado para descrever o método ■ elementTyPe.PARAMETER para descrever o parâmetro para descrever o parâmetro: o parâmetro usado para descrever o parâmetro para descrever o parâmetro para descrever o me elemento. Construtor ■ ElementType.Local_Variable: Usado para descrever a variável local ■ ElementType.annotation_type: Usado para descrever a anotação ■ ElementType.package: Usado para descrever o pacote
Herited Indication Indica que a anotação é herdada, ou seja, se um tipo de anotação modificado por @Inerited for usado para uma classe, a anotação também atuará na subclasse da classe modificada.
◦@repetível indica que a anotação anotada pode ser aplicada ao mesmo objeto várias vezes. 1.9 Adicionou anotação
Anotações personalizadas
Eu mencionei tantas anotações acima, e todo mundo se concentra nas metanotações. Quando personalizamos as anotações, geralmente usamos metanotações para nos ajudar. O formato de anotação personalizado é o nome public @Interface Anotation {Definition Body}. Ao usar a anotação personalizada @Interface, a interface java.lang.annotation.annotation é herdada automaticamente. Ao personalizar anotações, outras anotações ou interfaces não podem ser herdadas. O método declarado na anotação é na verdade um parâmetro de comentário. O nome do método é o nome do parâmetro e o tipo de valor de retorno é o tipo do parâmetro. O valor padrão do parâmetro pode ser declarado através do padrão.
As anotações personalizadas são simples, use @Interface para definir uma anotação, como segue.
@Retention (retentionPolicy.Runtime) @target (elementType.type) @DocumentEdPublic @Interface Classinfo {String autor () padrão "wang"; String date (); String Comments ();} Uma anotação personalizada chamada Classinfo. De acordo com o @retention, você pode saber que esta anotação sempre existirá, ou seja, essa anotação ainda é válida quando o programa estiver em execução; @Target (elementType.type) significa que a anotação Classinfo atua na classe, interface ou declaração de enum; @Documented
Instruções As informações do Classinfo podem ser gravadas em documentos Javadoc.
Vamos dar uma olhada em alguns parâmetros de anotação em anotações personalizadas. Existem três parâmetros de anotação. Os parâmetros de anotação podem ser definidos por padrão, como o parâmetro de anotação do autor, o valor padrão é Wang e os outros dois parâmetros não têm valores padrão.
Vejamos outra anotação personalizada.
@Retention (retentionPolicy.Runtime) @target (elementType.method) public @Interface MethodInfo {String Description () padrão "sem descrição"; String date ();}Esse método de anotação personalizado age no método, e essa anotação também existirá quando o programa estiver em execução; Existem dois parâmetros de anotação nele.
Para anotar a definição de parâmetros (definição do método), você pode usar apenas dois modificadores de direitos de acesso públicos ou inadimplentes. Os tipos de parâmetros suportam os seguintes tipos.
• Oito tipos de dados básicos (byte, int, curto, longo, flutuante, duplo, char, booleano)
• Tipo de string
• Tipo de classe
• Tipo de enumeração
• Tipo de anotação
• Matrizes de todos os tipos acima
Uso de anotações
Além das duas anotações acima, foi adicionada uma anotação com escopo de campo.
@Retention (retentionPolicy.Runtime) @target (elementType.field) public @Interface FieldInfo {string type (); Nome da String ();}Se os valores padrão não forem declarados em anotações personalizadas, esses parâmetros deverão receber valores atribuídos ao usar anotações personalizadas; caso contrário, o compilador relatará um erro.
Dê uma olhada no código usado pela anotação:
@Classinfo (autor = "wang", date = "2016/9/13", comentários = "anotação de demonstração") public class AnotationDemo {@FieldInfo (type = "public", name = "Firstfield") public int Firstfield; @FieldInfo (type = "privado", name = "Secondfield") Private String Secondfield; @Methodinfo (Descrição = "Método em AnoTationDemo", Name = "FirstMethod") public void FirstMethod (String value) {System.out.printf ("Primeiro método envolvido"); } @Methodinfo (description = "método em anotaçãoDemo", name = "SecondMethod") private void SecondMethod () {System.out.printf ("primeiro método envolvido"); }}Obtenha informações de anotação
Para obter informações sobre anotação, devemos primeiro garantir que a anotação exista durante a execução do programa. Portanto, geralmente adicionamos @rerention (retentionpolicy.runtime) meta -anotação às anotações personalizadas. Dessa forma, durante a execução do programa, podemos obter algumas informações de anotação através da reflexão. Para obter instruções sobre reflexão, você pode visualizar este artigo.
classe pública AnoTationTest {public static void main (string [] args) {resolveclassannotationInfo (anoTationDemo.class); resolvefieldannotationInfo (AnnotationDemo.class); resolvemethodannotationInfo (AnoTationDemo.class); } private estático void resolveclassannotationInfo (classe <?> clz) {// Determine se esta classe tem classificação de classificação if (clz.isannotationPresent (classinfo.class)) {classinfo classinfo = (classinfo) clz.getAnation (classinfo.cl); System.out.println (classinfo.author () + "" + classinfo.comments () + "" + classinfo.date ()); }} private estático void resolvefieldannotationInfo (classe <?> clz) {field [] campos = clz.getDecLaredFields (); para (campo de campo: campos) {if (field.isannotationPresent (fieldinfo.class)) {fieldInfo fieldInfo = (fieldInfo) field.getAnnotation (fieldInfo.class); System.out.println (fieldinfo.type () + "" + fieldInfo.name ()); }}} private estático void resolvemethOnnotationInfo (classe <?> clz) {métodos [] métodos = clz.getDecLaredMethods (); para (Método Método: Métodos) {if (Method.isannotationPresent (MethodInfo.class)) {MethodInfo MethodInfo = (MethodInfo) Method.getAnnotation (MethodInfo.class); System.out.println (MethodInfo.name () + "" + Metodinfo.Description ()); }}}}Reflexão para obter campo/método na classe, etc., e obter anotações relevantes através do getAnnotation () ou getAnnotações (). Você pode obter informações específicas obtendo as anotações específicas.
A saída do resultado da execução é a seguinte:
Figura 1 Diagrama de resultados de operação
Resumir
Para iniciantes de Java e até desenvolvedores de Java com certa experiência, eles podem ter menos exposição às anotações de Java. Na realidade, as anotações raramente são usadas, mas geralmente as vê no Código. Este artigo é uma introdução simples às anotações e, pelo menos no nível do código, é sem estresse ler.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.