1. Visão geral
As anotações podem ser definidas nos métodos.
Anotações comumente usadas:
@Override: significa um método para re-parente da classe,
Isso também pode determinar se o método da classe pai é substituído. Método da classe pai que é substituída.
@Suppresswarnings ("deprecação"): cancele o aviso do compilador (por exemplo, o método que você está usando está desatualizado)
@Deprecated: Esta afirmação também é colocada no topo do método, indicando que esse método está desatualizado ou usado na aula
A cópia do código é a seguinte:
importar java.util.arraylist;
importar java.util.list;
classe pública AnoTationDemo {
/*
* Para coleções, se nenhum tipo de armazenamento for especificado, haverá um aviso de segurança.
* Se você não deseja solicitar um aviso de segurança, adicione @suppresswarnings (parâmetro) à classe ou método.
*/
@Suppresswarnings ("sem controle")
public static void main (string [] args) {
Lista da lista = new ArrayList ();
}
}
2. Anotações personalizadas
1. Formato
Permissões @Interface Anotation Name {}
etapa:
Definir classe de anotação ---> Definir a classe da classe de anotação do aplicativo ---> Classe que reflete a classe da classe de anotação do aplicativo (esta classe pode ser definida separadamente ou testada na classe de anotação do aplicativo)
A cópia do código é a seguinte:
importar java.lang.annotation.retention;
importJava.lang.annotation.retEntionPolicy;
// Defina esta anotação a ser mantida em bytecode
@Retention (retentionpolicy.runtime)
public @interface myannotation {
}
@Myannotation
// Classe de anotação Application-Defined
classe pública ApplyMyannotation {
public static void main (string [] args) {
if (applymyannotation.class.isannotationPresent (myannotation.class)) {// determinar se existe uma classe de anotação especificada nesta classe
Myannotation Anotation = (Myannotation) ApplyMyannotation.class
.getannotation (myannotation.class);
System.out.println (anotação);
}
}
}
2. Ciclo de declaração
Formato: por exemplo: @retention (retentionpolicy.class)
Definir ciclos em uma classe de anotação personalizada, @retention (tipo de parâmetro) Tipo de parâmetro é retentionpolicy
RetentionPolicy.class: No arquivo de classe, a máquina virtual não mantém as anotações durante o tempo de execução
RetentionPolicy.Runtime: No arquivo da classe, os comentários virtuais são retidos durante o tempo de execução.
RetentionPolicy.source: No arquivo de origem, descarte a anotação
Suppresswarnings e Substituir são retentionpolicy.source,
Depreciado está em retençãopolicy.runtime.
O padrão é retentionpolicy.class:
3. Especifique o alvo
Formato: por exemplo: Método @target (ElementType.method)
O que os membros podem ser anotados pela anotação definida. Se esta anotação não for declarada, poderá ser colocada em qualquer elemento do programa.
Pode ser pacotes, interfaces, parâmetros, métodos, variáveis locais, campos, etc.
A cópia do código é a seguinte:
// Defina esta anotação a ser mantida em bytecode
@Retention (retentionpolicy.runtime)
@Target ({elementType.method, elementType.type}) // pode ser definido em métodos e classes para representar tipos
public @interface myannotation {
}
@Myannotation
// Classe de anotação Application-Defined
classe pública ApplyMyannotation {
@Myannotation // definido no método
public static void main (string [] args) {
if (applymyannotation.class.isannotationPresent (myannotation.class)) {// determinar se existe uma classe de anotação especificada nesta classe
Myannotation Anotation = (Myannotation) ApplyMyannotation.class
.getannotation (myannotation.class);
System.out.println (anotação);
}
}
}
3. Adicione atributos à anotação
1. Tipo
As configurações de atributo das anotações podem ser: 8 tipos de dados básicos, string, enumeração, anotação, classe, tipos de matriz,
2. Preste atenção
Se houver apenas um atributo na anotação ou apenas um atributo precisará ser atribuído, ele poderá ser escrito diretamente quando chamado sem especificar o nome do atributo.
Quando o atributo anotado é um tipo de matriz e apenas um valor é atribuído ao atribuir, {} pode ser omitido.
3. Exemplo
3.1. Tipo de atributo (Is String)
A cópia do código é a seguinte:
importar java.lang.annotation.ElementType;
importar java.lang.annotation.retention;
importar java.lang.annotation.retEntionPolicy;
importar java.lang.annotation.*;
// Defina esta anotação a ser mantida em bytecode
@Retention (retentionpolicy.runtime)
public @interface myannotation {
String value ();
String color () padrão "vermelho"; // Defina o valor padrão é "vermelho"
}
@Myannotation ("java")
classe pública ApplyMyannotation {
public static void main (string [] args) {
/**
* Isso é para obter a anotação na classe e você também pode obter a anotação no método.
*/
if (applymyannotation.class.isannotationPresent (myannotation.class)) {// determinar se existe uma classe de anotação especificada nesta classe
Myannotation Anotation = (Myannotation) ApplyMyannotation.class
.getannotation (myannotation.class);
System.out.println ("value ="+anoTation.value ());
System.out.println ("color ="+anoTation.color ());
}
}
}
resultado:
valor = java
Cor = vermelho
No programa de chamada, também pode ser visto que, se apenas um atributo puder ser atribuído, o nome do atributo poderá ser omitido. Caso contrário, @ classe de anotação (nome do atributo = valor)
3.2
A cópia do código é a seguinte:
/*Enum classe*/
Semana Public Enum {
Sol, seg;
}
/**
* Classe de anotação
*/
public @Interface AnoTationText {
String value ();
}
importar java.lang.annotation.ElementType;
importar java.lang.annotation.retention;
importar java.lang.annotation.retEntionPolicy;
importar java.lang.annotation.*;
// Defina esta anotação a ser mantida em bytecode
@Retention (retentionpolicy.runtime)
public @interface myannotation {
String value ();
String color () padrão "vermelho"; // Defina o valor padrão é "vermelho"
Semana da semana () semana padrão.mon; // tipo de enum
int [] array () padrão {1,2,3}; // tipo de matriz
anotationText anoTation () @AnnoTationText ("my");
Classe ClassDemo () Inteiro Padrão.class; // Tipo de classe
}
@Myannotation (value = "java", color = "verde", semana = semana.sun, array = 5, anotação =@annotationText ("you"), classdemo = string.class) // Array = {4,5, 6}
classe pública ApplyMyannotation {
public static void main (string [] args) {
/**
* Isso é para obter a anotação na classe e você também pode obter a anotação no método.
*/
if (applymyannotation.class.isannotationPresent (myannotation.class)) {// determinar se existe uma classe de anotação especificada nesta classe
Myannotation Anotation = (Myannotation) ApplyMyannotation.class
.getannotation (myannotation.class);
System.out.println ("value ="+anoTation.value ());
System.out.println ("color ="+anoTation.color ());
System.out.println ("week ="+anoTation.week ());
System.out.println ("Array comprimento ="+anotação.array (). Comprimento);
System.out.println ("Tipo de anotação value ="+anotação.annotation (). Value ());
System.out.println ("Classe Type Value ="+ANNOTATION.CLASSDEMO ());
}
}
}
resultado:
A cópia do código é a seguinte:
valor = java
Cor = verde
Semana = sol
Comprimento da matriz = 1
Valor do tipo de anotação = você
Tipo de classe Valor = Classjava.lang.string
4. Anotações no método
A cópia do código é a seguinte:
importJava.lang.annotation.retention;
importJava.lang.annotation.retEntionPolicy;
/**
*Classe de anotação
*/
@Retention (retentionpolicy.runtime)
public @Interface AnoTationText {
StringValue ();
}
publicClassApplyMyannotation {
publicstaticVoidMain (String [] args) ThrowSexception {
MethodMethodShow = ApplyMyannotation.class.getMethod ("show");
anoTationTexTanno = Methodshow.getAnnotation (ANNOTATIONTEXT.CLASS);
System.out.println (Anno.Value ());
}
@annotationText ("java")
publicVoidShow () {
System.out.println ("Hello");
}
}
Resultados: Java