O que é anotação:
Anotação (anotação) é uma forma e método fornecido por Java para associar qualquer informação e quaisquer metadados (metadados) a elementos no metaprograma. Anotação (anotação) é uma interface. O programa pode obter o objeto Annotation do elemento de programa especificado por meio de reflexão e, em seguida, obter os metadados na anotação por meio do objeto Annotation.
A anotação (anotação) é introduzida no JDK5.0 e versões posteriores. Ele pode ser usado para criar documentação, rastrear dependências em seu código e até mesmo realizar verificações básicas em tempo de compilação. De certa forma, as anotações são usadas como modificadores e aplicadas à declaração de pacotes, tipos, construtores, métodos, variáveis de membro, parâmetros e variáveis locais. Essas informações são armazenadas no par de estruturas "nome=valor" da Anotação.
Os membros de uma Annotation são declarados como métodos sem parâmetros no tipo Annotation. O nome do método e o valor de retorno definem o nome e o tipo do membro. Há uma sintaxe padrão específica aqui: é permitido declarar o valor padrão de qualquer membro da Anotação: uma Anotação pode usar um par nome=valor como o valor de um membro da Anotação que não define um valor padrão. =value pair também pode ser usado para substituir o valor padrão de outros membros. Isso é um pouco semelhante às características de herança das classes. O construtor da classe pai pode ser usado como construtor padrão da subclasse, mas também pode ser substituído pela subclasse.
A anotação pode ser usada para associar qualquer informação a um elemento do programa (classe, método, variável de membro, etc.). Deve-se notar que existe uma regra básica aqui: a anotação não pode afetar a execução do código do programa. Não importa se a anotação é adicionada ou excluída, o código será executado de forma consistente. Além disso, embora algumas anotações sejam acessadas em tempo de execução por meio dos métodos API de reflexão do Java, o interpretador da linguagem Java ignora essas anotações durante o trabalho. É precisamente porque a máquina virtual Java ignora a anotação que o tipo de anotação “não funciona” no código; as informações no tipo de anotação só podem ser acessadas e processadas por meio de algumas ferramentas de suporte; Este artigo abordará os tipos de anotação padrão e meta-anotação. A ferramenta que acompanha esses tipos de anotação é o compilador Java (que, obviamente, os trata de uma maneira especial).
-------------------------------------------------- ----------------------------------
O que são metadados (metadados):
Metadados é traduzido da palavra metadados, que significa “dados sobre dados”.
Os metadados têm muitas funções. Por exemplo, você pode ter usado comentários Javadoc para gerar documentação automaticamente. Este é um tipo de função de metadados. Em geral, os metadados podem ser usados para criar documentação, rastrear dependências de código, realizar verificações de formato em tempo de compilação e substituir arquivos de configuração existentes. Se quisermos classificar a função dos metadados, atualmente não existe uma definição clara, mas podemos dividi-los aproximadamente em três categorias com base na sua função:
1. Escrevendo documentos: Gerando documentos por meio dos metadados identificados no código 2. Análise de código: Analisando o código por meio dos metadados identificados no código 3. Verificação de compilação: Usando os metadados identificados no código, o compilador pode realizar a compilação básica Verifique se metadados em Java existem no código Java na forma de tags. A existência de tags de metadados não afeta a compilação e execução do código do programa. Eles são usados apenas para gerar outros arquivos ou para conhecer o código que está sendo executado em tempo de execução. Informação.
Resumindo:
Primeiro, os metadados existem no código Java na forma de tags.
Em segundo lugar, as informações descritas pelos metadados são de tipo seguro, ou seja, os campos nos metadados têm tipos claros.
Terceiro, os metadados requerem processamento adicional por ferramentas diferentes do compilador usado para gerar outros componentes do programa.
Quarto, os metadados só podem existir no nível do código-fonte Java ou podem existir dentro do arquivo Class compilado.
-------------------------------------------------- ----------------------------------
Tipos de anotação e anotação:
Anotação:
A anotação usa a nova sintaxe trazida no java5.0 e seu comportamento é muito semelhante a modificadores como público e final. Cada anotação possui um nome e o número de membros >=0. Cada membro de uma anotação tem um nome e um valor chamado par nome=valor (assim como um javabean), e nome=valor carrega as informações da anotação.
Tipo de anotação:
O tipo de anotação define o nome, o tipo e o valor padrão do membro da anotação. Pode-se dizer que um tipo de anotação é uma interface Java especial. Suas variáveis de membro são restritas e uma nova sintaxe é necessária ao declarar um tipo de anotação. Quando acessamos Annotation através da API de reflexão Java, o valor de retorno será um objeto que implementa a interface do tipo de anotação. Ao acessar este objeto, podemos acessar facilmente seus membros Annotation. Os capítulos a seguir mencionarão os três tipos de anotação padrão incluídos no pacote java.lang do java5.0.
-------------------------------------------------- ----------------------------------
Categorias de anotação:
De acordo com o número de parâmetros de anotação, podemos dividir as anotações em três categorias:
1. Anotação de marca: um tipo de anotação sem definição de membro é chamado de anotação de marca. Este tipo de Anotação utiliza apenas sua própria presença ou ausência para nos fornecer informações. Por exemplo, a seguinte anotação de sistema @Override;
2. Anotação de valor único 3. Anotação completa
De acordo com o uso e a finalidade das anotações, podemos dividir as anotações em três categorias:
1. Anotações do sistema integrado JDK 2. Meta anotações 3. Anotações personalizadas
-------------------------------------------------- ----------------------------------
Anotações padrão integradas no sistema:
A sintaxe das anotações é relativamente simples, exceto pelo uso do símbolo @, é basicamente consistente com a sintaxe inerente do Java. Existem três anotações padrão incorporadas no JavaSE, que são definidas em java.lang:
@Override: Usado para modificar este método para substituir o método da classe pai;
@Deprecated: usado para modificar métodos obsoletos;
@SuppressWarnings: usado para notificar o compilador Java para suprimir avisos de compilação específicos.
Vamos dar uma olhada nas funções e nos cenários de uso das três anotações padrão integradas.
-------------------------------------------------- ----------------------------------
@Override, restringe a substituição dos métodos da classe pai:
@Override é um tipo de anotação de marcador usado para anotar métodos. Mostra que o método anotado sobrecarrega o método da classe pai e desempenha o papel de asserção. Se usarmos esse tipo de anotação em um método que não substitui o método da classe pai, o compilador Java irá avisá-lo com um erro de compilação. Essa anotação geralmente entra em ação quando tentamos substituir um método de classe pai, mas escrevemos o nome do método errado. O uso é extremamente simples: ao utilizar esta anotação, basta adicionar @Override na frente do método modificado. O código a seguir é um exemplo de uso de @Override para modificar o método displayName() de uma tentativa de substituir a classe pai, mas há erros de ortografia:
public void displayName(){
System.out.println("O nome da fruta é: *****");
}
}
classe Laranja estende Fruta {
@Substituir
public void displayName(){
System.out.println("O nome da fruta é: laranja");
}
}
class Apple estende Fruta {
@Substituir
public void nome de exibição(){
System.out.println("O nome da fruta é: Maçã");
}
}
@Deprecated, a tag está obsoleta:
Da mesma forma, Deprecated também é uma anotação de marcação. Quando um tipo ou membro de tipo é decorado com @Deprecated, o compilador desencorajará o uso desse elemento de programa anotado. E esse tipo de modificação tem um certo grau de “continuidade”: se usarmos esse tipo ou membro desatualizado no código por meio de herança ou substituição, embora o tipo ou membro herdado ou substituído não seja declarado @Deprecated, o compilador ainda precisa avisar você.
É importante notar que há uma diferença entre o tipo de anotação @Deprecated e a tag @deprecated no javadoc: a primeira é reconhecida pelo compilador java, enquanto a última é reconhecida pela ferramenta javadoc e usada para gerar documentação (incluindo por que o programa membros são obsoletos e sua descrição de como deve ser proibido ou substituído).
No Java 5.0, o compilador Java ainda procura as tags Javadoc @deprecated e as utiliza para gerar mensagens de aviso, como fazia nas versões anteriores. Mas esta situação mudará nas versões subsequentes, e devemos começar a usar @Deprecated agora para decorar métodos obsoletos em vez da tag @deprecated javadoc.
No programa a seguir, a anotação @Deprecated é usada para marcar o método como expirado. Ao mesmo tempo, a tag @deprecated é usada na anotação do método para marcar o método como expirado.
/**
* @deprecated Este método expirou e não é recomendado.
*/
@Obsoleto
public void showTaste(){
System.out.println("O sabor das maçãs frutadas é: crocante e doce");
}
public void showTaste(int typeId){
if(typeId==1){
System.out.println("O sabor da fruta maçã é: azedo");
}
senão if(typeId==2){
System.out.println("O sabor das maçãs frutadas é: doce");
}
outro{
System.out.println("O sabor das maçãs frutadas é: crocante e doce");
}
}
}
classe pública FruitRun {
/**
* @param argumentos
*/
public static void main(String[] args) {
Maçã maçã=nova Maçã();
apple.nomedisplay();
AppleService appleService=new AppleService();
appleService.showTaste();
appleService.showTaste(0);
appleService.showTaste(2);
}
}
-------------------------------------------------- ----------------------------------
SuppressWarnings, suprime avisos do compilador:
@SuppressWarnings é usado para desativar seletivamente os avisos do compilador para classes, métodos, variáveis de membro e inicialização de variáveis. Em java5.0, o compilador javac fornecido pela sun nos fornece a opção -Xlint para permitir que o compilador avise contra código de programa legal. Este aviso representa um erro de programa até certo ponto. Por exemplo, quando usamos uma classe de coleção genérica sem fornecer seu tipo, o compilador solicitará um aviso de “aviso não verificado”. Normalmente, quando isso acontece, precisamos encontrar o código que causou o aviso. Se realmente representa um erro, precisamos corrigi-lo. Por exemplo, se a mensagem de aviso indicar que a instrução switch em nosso código não cobre todos os casos possíveis, devemos adicionar um caso padrão para evitar esse aviso.
Às vezes não podemos evitar esse aviso. Por exemplo, não podemos evitar esse aviso não verificado quando usamos uma classe de coleção genérica que deve interagir com código antigo não genérico. @SuppressWarning será útil neste momento. Adicione a modificação @SuppressWarnings antes do método chamado para informar ao compilador para parar de avisar sobre esse método.
SuppressWarning não é uma anotação de marcação. Possui um membro do tipo String[], o valor deste membro é o nome do aviso proibido. Para o compilador javac, os nomes de aviso válidos para a opção -Xlint também são válidos para @SuppressWarings e o compilador ignora nomes de aviso não reconhecidos.
A sintaxe da anotação permite que o nome da anotação seja seguido por parênteses. Nos parênteses estão os pares nome=valor separados por vírgula usados para atribuir valores aos membros da anotação. Os exemplos são os seguintes:
@SuppressWarnings(value={ "rawtypes", "unchecked" })
public static List<Frutas> getFruitList(){
List<Frutas> FruitList=new ArrayList();
return listadefrutas;
}
@SuppressWarnings({ "rawtypes", "desmarcado" })
public static List<Fruit> getFruit(){
List<Frutas> FruitList=new ArrayList();
return listadefrutas;
}
@SuppressWarnings("não utilizado")
public static void main(String[] args){
List<String> strList=new ArrayList<String>();
}
}
Uma breve descrição dos valores de parâmetros comuns anotados por SuppressWarnings:
1.deprecation: Aviso quando classes ou métodos obsoletos são usados;
2. unchecked: Aviso quando uma conversão não verificada é realizada, por exemplo, ao usar uma coleção, os genéricos não são usados para especificar o tipo de coleção salva;
3.fallthrough: Aviso quando o bloco de programa Switch leva diretamente para a próxima situação sem Break;
4.path: Aviso quando há caminhos inexistentes no caminho da classe, caminho do arquivo de origem, etc.;
5.serial: Aviso quando a definição serialVersionUID está faltando em uma classe serializável;
6.finalmente: Aviso quando alguma cláusula final não pode ser concluída normalmente;
7.all: Aviso sobre todas as situações acima.