Para aprender as anotações em profundidade, devemos ser capazes de definir nossas próprias anotações e usá-las. Antes de definir nossas próprias anotações, devemos entender a sintaxe das meta-anotações e das anotações de definição relacionadas fornecidas por Java.
-------------------------------------------------- ----------------------------------
Meta anotação:
A função das meta-anotações é anotar outras anotações. Java5.0 define quatro tipos de metaanotação padrão, que são usados para fornecer descrições de outros tipos de anotação. Meta-anotações definidas por Java5.0:
1.@Alvo,
2.@Retenção,
3.@Documentado,
4.@Herdado
Esses tipos e as classes que eles suportam são encontrados no pacote java.lang.annotation. Vamos dar uma olhada na função de cada metaanotação e nas instruções para usar os subparâmetros correspondentes.
-------------------------------------------------- ----------------------------------
@Alvo:
@Target explica o escopo dos objetos modificados pela anotação: a anotação pode ser usada para pacotes, tipos (classes, interfaces, enumerações, tipos de anotação), membros de tipo (métodos, construtores, variáveis de membro, valores de enumeração), parâmetros de método e variáveis locais ( como variáveis de loop, parâmetros de captura). Usar target na declaração do tipo Annotation pode tornar o alvo modificado mais claro.
Função: Usada para descrever o escopo de uso das anotações (ou seja: onde as anotações descritas podem ser usadas)
Os valores (ElementType) são:
1.CONSTRUCTOR: usado para descrever o construtor 2.FIELD: usado para descrever o domínio 3.LOCAL_VARIABLE: usado para descrever variáveis locais 4.METHOD: usado para descrever o método 5.PACKAGE: usado para descrever o pacote 6.PARAMETER: usado para descrever os parâmetros 7.TYPE: usado para descrever classes, interfaces (incluindo tipos de anotação) ou declarações enum
Exemplos de uso:
@Target(ElementType.FIELD)
public @interface NoDBColumn {
}
-------------------------------------------------- ----------------------------------
@Retenção:
@Retention define o período de tempo que a anotação é retida: algumas anotações aparecem apenas no código-fonte e são descartadas pelo compilador enquanto outras são compiladas no arquivo de classe. As anotações compiladas no arquivo de classe podem ser virtualizadas. enquanto outros serão lidos quando a classe for carregada (observe que isso não afeta a execução da classe, porque a anotação e a classe são usadas separadamente). Use esta meta-anotação para limitar o "ciclo de vida" da anotação.
Função: Indica em que nível as informações da anotação precisam ser salvas e é usada para descrever o ciclo de vida da anotação (ou seja: dentro de qual escopo a anotação descrita é válida)
Os valores (RetentionPoicy) são:
1.SOURCE: Válido no arquivo de origem (ou seja, o arquivo de origem é retido)
2.CLASS: Válido em arquivos de classe (ou seja, classe reservada)
3.RUNTIME: válido em tempo de execução (ou seja, retido em tempo de execução)
O tipo de meta-anotação Retention tem um valor exclusivo como membro e seu valor vem do valor do tipo de enumeração de java.lang.annotation.RetentionPolicy. Exemplos específicos são os seguintes:
-------------------------------------------------- ----------------------------------
@Documentado:
@Documented é usado para descrever outros tipos de anotação que devem ser usados como API pública dos membros do programa anotado e, portanto, podem ser documentados por ferramentas como o javadoc. Documentado é uma anotação de marcação e não possui membros.
A meta-anotação @Inherited é uma anotação de marcação. @Inherited afirma que um determinado tipo anotado é herdado. Se um tipo de anotação modificado com @Inherited for usado para uma classe, esta anotação será usada para subclasses dessa classe.
Nota: Os tipos de anotação @Inherited são herdados por subclasses da classe anotada. Uma classe não herda a anotação da interface que implementa e um método não herda a anotação do método que sobrecarrega.
Quando a Retenção da anotação anotada com o tipo de anotação @Inherited é RetentionPolicy.RUNTIME, a API de reflexão aprimora essa herança. Se usarmos java.lang.reflect para consultar a anotação de um tipo de anotação @Inherited, a inspeção reflexiva do código começará a funcionar: verificando a classe e sua classe pai até que o tipo de anotação especificado seja encontrado ou o nível superior da estrutura de herança da classe é alcançado.
Código de exemplo:
-------------------------------------------------- ----------------------------------
Anotação personalizada:
Ao usar @interface para personalizar anotações, a interface java.lang.annotation.Annotation é herdada automaticamente e outros detalhes são preenchidos automaticamente pelo compilador. Ao definir anotações, você não pode herdar outras anotações ou interfaces. @interface é usado para declarar uma anotação e cada método, na verdade, declara um parâmetro de configuração. O nome do método é o nome do parâmetro e o tipo de valor de retorno é o tipo do parâmetro (o tipo de valor de retorno só pode ser tipos básicos, Classe, String ou enum). Você pode declarar o valor padrão de um parâmetro por meio de default.
Defina o formato da anotação:
nome da anotação pública @interface {corpo da definição}
Tipos de dados suportados de parâmetros de anotação:
1. Todos os tipos de dados básicos (int, float, boolean, byte, double, char, long, short)
2. Tipo de string 3. Tipo de classe 4. Tipo de enumeração 5. Tipo de anotação 6. Matrizes de todos os tipos acima
Como definir os parâmetros no tipo Anotação:
Primeiro, ele só pode ser modificado com os dois direitos de acesso público ou padrão. Por exemplo, String value();
Em segundo lugar, os membros do parâmetro só podem usar os oito tipos de dados básicos de byte, short, char, int, long, float, double, boolean e tipos de dados como String, Enum, Class, anotações e matrizes desses tipos. String value();O membro do parâmetro aqui é String;
Terceiro, se houver apenas um membro de parâmetro, é melhor definir o nome do parâmetro como "valor" seguido de parênteses. Exemplo: A anotação FruitName no exemplo a seguir possui apenas um membro de parâmetro.
Anotações personalizadas simples e exemplos de uso de anotações:
importar java.lang.annotation.Documented;
importar java.lang.annotation.ElementType;
importar java.lang.annotation.Retention;
importar java.lang.annotation.RetentionPolicy;
importar java.lang.annotation.Target;
/**
* Notas sobre nomes de frutas
* @autor peida
*
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documentado
public @interface FruitName {
String valor() padrão "";
}
importar java.lang.annotation.Documented;
importar java.lang.annotation.ElementType;
importar java.lang.annotation.Retention;
importar java.lang.annotation.RetentionPolicy;
importar java.lang.annotation.Target;
/**
* Anotação de cor de fruta
* @autor peida
*
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documentado
public @interface FruitColor {
/**
* Enumeração de cores
* @autor peida
*
*/
enum público Cor{BULE,RED,GREEN};
/**
* Atributos de cor
* @retornar
*/
Cor frutaColor() padrão Color.GREEN;
}
anotação de importação.FruitColor.Color;
classe pública Apple {
@FruitName("Maçã")
private String nomeApple;
@FruitColor(fruitColor=Color.RED)
string privada appleColor;
public void setAppleColor(String appleColor) {
this.appleColor = appleColor;
}
public String getAppleColor() {
return appleColor;
}
public void setAppleName(String appleName) {
this.appleName = appleName;
}
public String getAppleName() {
return nomemaçã;
}
public void displayName(){
System.out.println("O nome da fruta é: Maçã");
}
}