Anotações Java simples
Existem apenas três tipos de anotação simples fornecidos pelo JDK5. Esses três são usados para evitar erros ou fornecer lembretes, a saber:
1.Substituir
2. Obsoleto
3. Suprimir avisos
É importante observar que JDK5 (outro termo, Tiger) na verdade não possui muitas anotações integradas; em vez disso, ele permite que o Java principal suporte a capacidade de recursos de anotação. definir funções de metadados. Ele precisa ser escrito pelo programador. Tipos de anotação personalizada, outros padrões JSR também escreveram uma série de tipos de anotação padrão.
Substituir anotação
A anotação Override indica que o método anotado precisa substituir o método na superclasse.
Se um método usar esta anotação, mas não substituir o método na superclasse (por exemplo, a capitalização está errada, ou os parâmetros estão errados, ou o método é definido pela própria subclasse), o compilador gerará um erro.
(Nota: Anotações de substituição não podem ser usadas no JRE5 ao implementar métodos em interfaces. O JRE6 permite isso. Muitas vezes o JRE5 reportará esse erro).
O exemplo 1 demonstra a substituição de anotações:
Exemplo de anotação Java 1:
Copie o código do código da seguinte forma:
classe pública Test_Override {
@Substituir
string pública paraString() {
return super.toString() + "Teste usando a anotação 'Substituir'";
}
}
O que acontece se o nome do método for digitado incorretamente? Por exemplo, se você renomear o método toString para "tostring" (tudo em letras minúsculas), receberá uma mensagem de erro semelhante a esta durante a compilação:
Copie o código do código da seguinte forma:
Compilando 1 arquivo fonte para D:tempNew Folder (2)
TestJavaApplication1buildclasses
D:tempNova pasta (2)TestJavaApplication1srctest
myannotationTest_Override.java:24: o método não substitui
um método de sua superclasse
@Substituir
1 erro
FALHA NA CONSTRUÇÃO (tempo total: 0 segundos)
Claro, o Eclipse reportará diretamente uma cruz vermelha. Agora que os IDEs se tornaram muito fáceis de usar, os iniciantes não devem mexer na linha de comando do JDK.
Anotação obsoleta
Esta anotação indica que o compilador deve exibir uma mensagem de aviso se o programa chamar um elemento obsoleto (Deprecated, obsolete, obsolete). O Exemplo 2 mostra como usar a anotação Deprecated.
Exemplo de anotação Java 2
Primeiro, crie uma classe e marque um método como obsoleto assim:
Copie o código do código da seguinte forma:
classe pública Test_Deprecated {
@Obsoleto
public void doSomething() {
System.out.println("Teste usando anotação obsoleta: 'Obsoleto'");
}
}
A seguir, tente chamar este método de outra classe:
Copie o código do código da seguinte forma:
classe pública TestAnnotations {
public static void main(String arg[]) lança exceção {
new TestAnnotations();
}
public TestAnnotations() {
Test_Deprecated t2=new Test_Deprecated();
t2.doAlguma coisa();
}
O método doSomething() neste exemplo é declarado como um método obsoleto. Portanto, este método não deve ser chamado em circunstâncias normais. Não haverá mensagem de aviso ao compilar o arquivo Test_Deprecated.java. Uma mensagem de aviso semelhante a esta será dada (o Eclipse irá avisar):
Copie o código do código da seguinte forma:
Compilando 1 arquivo fonte para D:tempNew Folder
(2) TestJavaApplication1buildclasses
D:tempNova pasta
(2)TestJavaApplication1srctestmyannotation
TestAnnotations.java:27:
aviso: [descontinuação] doSomething() em
test.myannotation.Test_Deprecated foi descontinuado
t2.doAlguma coisa();
1 aviso
Suprimir anotação de avisos
Esta anotação informa ao compilador que as mensagens de aviso para o elemento anotado e todos os subelementos devem ser suprimidas. Todas as mensagens de aviso para um conjunto de elementos e subelementos serão suprimidas. Por exemplo, suponha que você use a anotação Suppresswarnings em uma classe. suprimir um aviso Se você usar a anotação Suppresswarnings em um método para suprimir outro aviso, ambos os avisos serão suprimidos no nível do método.
Exemplo de anotação Java 3:
Copie o código do código da seguinte forma:
classe pública TestAnnotations {
public static void main(String arg[]) lança exceção {
new TestAnnotations().doSomeTestNow();
}
@SuppressWarnings({"descontinuação"})
public void doSomeTestNow() {
Test_Deprecated t2 = novo Test_Deprecated();
t2.doAlguma coisa();
}
}
Neste exemplo, @SuppressWarnings é usado para suprimir a mensagem de aviso de descontinuação mostrada no Exemplo 2. Como esse tipo de aviso para esse método é suprimido, você não verá mais o aviso de "depreciação".
Nota: É melhor usar esta anotação no elemento mais interno. Portanto, se você deseja suprimir apenas um aviso em um método específico, você deve anotá-lo no método em vez de usar a anotação na classe.
Meta-anotações (tipo de anotação Java)
As meta-anotações, na verdade chamadas de anotações, incluem quatro tipos:
1. Alvo
2.Retenção
3. Documentado
4. Herdado
Anotação de destino
A anotação Target indica a qual elemento de destino o tipo de anotação se aplica. Ela contém os seguintes valores de tipo de enumeração:
1.@Target(ElementType.TYPE) – pode ser aplicado a elementos de qualquer classe
2.@Target(ElementType.FIELD) - aplica-se apenas a campos ou propriedades
3.@Target(ElementType.METHOD) - aplicável apenas a anotações de método
4.@Target(ElementType.PARAMETER) - aplica-se apenas a parâmetros de método
5.@Target(ElementType.CONSTRUCTOR) – aplicável apenas a construtores
6.@Target(ElementType.LOCAL_VARIABLE) – aplicável apenas a variáveis locais
7.@Target(ElementType.ANNOTATION_TYPE) —— Indica que o próprio tipo declarado é um tipo de anotação
O exemplo 4 demonstra a anotação Target:
Exemplo de anotação Java 4
Primeiro, é definido um tipo de anotação chamado Test_Target, com a meta-anotação @Target, conforme mostrado abaixo:
Copie o código do código da seguinte forma:
@Target(ElementType.METHOD)
public @interface Test_Target {
public String doTestTarget();
}
A seguir, crie uma classe que será anotada com Test_Target:
Copie o código do código da seguinte forma:
classe pública TestAnnotations {
public static void main(String arg[]) {
novo TestAnnotations().doTestTarget();
}
// Use anotações nos métodos, OK.
// Não pode haver quebras de linha no meio, 2 linhas, etc. Java ignora quebras de linha redundantes.
@Test_Target(doTestTarget="Olá, Mundo!")
public void doTestTarget() {
System.out.printf("Testando anotação de destino");
}
}
A anotação @Target(ElementType.METHOD) indica que o tipo de anotação só pode ser usado para anotar métodos. Se você compilar este código, nenhuma mensagem de aviso será exibida. Porém, o que acontecerá se esta anotação for declarada em uma variável de string? O que?
Copie o código do código da seguinte forma:
classe pública TestAnnotations {
// Esta é uma abordagem errada e a compilação não será aprovada porque a anotação está no nível errado.
// Meta-anotações indicam que apenas métodos podem ser anotados e não podem ser usados para anotar propriedades.
@Test_Target(doTestTarget="Olá, Mundo!")
cadeia de caracteres privada;
public static void main(String arg[]) {
novo TestAnnotations().doTestTarget();
}
public void doTestTarget() {
System.out.printf("Testando anotação de destino");
}
}
A única mudança é que a declaração da anotação passa do nível do método para o nível do campo, o que é incorreto. Como você definiu a anotação @Test_Target se aplica apenas no nível do método, se você tentar compilar esta classe, poderá obter um erro. mensagem como esta:
Copie o código do código da seguinte forma:
"TestAnnotations.java":
D:R_AND_DTestAnnotationsrctestmyannotation
TestAnnotations.java:16:
tipo de anotação não aplicável a este tipo de declaração na linha
16, coluna 0
@Test_Target(doTestTarget="Olá, Mundo!")
^
Erro na compilação javac