Em Java, a anotação é introduzida no Java 5 e é usada para descrever as meta informações do código Java. Geralmente, as anotações não afetam diretamente a execução do código, embora algumas anotações possam ser usadas para afetar a execução do código.
O que pode ser feito com anotações
Anotações em Java geralmente desempenham os seguintes papéis
em
Noções básicas de anotação
Uma anotação Java simples é semelhante à @Entity. Onde @ significa dizer ao compilador que esta é uma anotação. Entidade é o nome da anotação. Geralmente em um arquivo, o método de escrita é o seguinte
Public @Interface entity {
}
Elementos de anotação
As anotações Java podem usar elementos para definir alguns valores, e os elementos nas anotações são semelhantes aos atributos ou parâmetros. Código de amostra para definir elementos contendo a anotação
Public @Interface entity {
String tableName ();
}
Código de amostra usando elementos contendo anotação
@Entity (tableName = "veículos")
O nome do elemento da anotação acima é o tableName e o conjunto de valores são veículos. As anotações sem elementos não requerem parênteses.
Se a anotação contiver vários elementos, o método de uso é o seguinte
@Entity (tableName = "veículos", primarykey = "id")
Se a anotação tiver apenas um elemento, geralmente escrevemos assim
@InsertNew (value = "sim")
Mas, neste caso, se e somente se o nome do elemento for valor, também podemos abreviar -o, ou seja, não há necessidade de preencher o valor do nome do elemento, o efeito é o seguinte
@InsertNew ("sim")
Uso da anotação
As anotações podem ser usadas para modificar esses elementos no código
Um exemplo completo de uso é o seguinte
@EntityPublic Class Veículo {@Persistent Protected String vehicleName = null; @Getter public string getvehicleName () {return this.vehicleName; } public void setVehicleName (@Optcional vehicleName) {this.vehicleName = vehicleName; } Lista pública AddVeHiclenameTolist (Nomes da lista) {@Optional List SocalNames = Names; if (localNames == null) {localNames = new ArrayList (); } localNames.add (getvehicleName ()); devolver nomes locais; }}Anotações Java embutidas
Existem três anotações internas no Java que são usadas para fornecer instruções para o compilador. Eles são
@Deprecated
Pode ser usado para marcar classes, métodos e propriedades.
Se os três elementos acima não forem mais usados, use a anotação @Deprecated. Se o código usar a classe, método ou propriedade da anotação @Deprecated, o compilador o alertará.
@Deprecated é muito simples de usar, como segue: anotação de uma classe depreciada.
@DeprecatedPublic Classe MyComponent {}Quando usamos a anotação @Deprecated, é recomendável usar o símbolo Javadoc @Deprecated correspondente em conjunto e explicar por que essa classe, método ou propriedade está obsoleto e qual é a alternativa.
@Deprecated/** @Deprecated Esta classe está cheia de bugs. Use MyNewComponent.
@Override
A anotação @Override é usada para modificar o método de reescrever a classe pai. Se um método que não substituir a classe pai usa essa anotação, o compilador solicitará um erro.
De fato, @Overide não é necessário substituir os métodos da classe ou interface pai em uma subclasse. No entanto, ainda é recomendável usar esta anotação. Em alguns casos, assumindo que você modifique o nome do método da classe pai, o método da subclasse que foi reescrito antes não será mais reescrito. Sem @Overide, você não notará o método desta subclasse. Com esta modificação da anotação, o compilador solicitará essas informações.
Exemplos de uso de anotação de substituição
classe pública mysuperclass {public void Dothething () {System.out.println ("Do The Thing"); }} classe pública mysubclass estende mysuperclass {@Override public void Dothething () {System.out.println ("faça isso de maneira diferente"); }}@Suppresswarnings
@Suppresswarnings é usado para suprimir o compilador de gerar mensagens de aviso.
Os elementos que podem ser modificados são classes, métodos, parâmetros de método, atributos e variáveis locais
Cenário de uso: quando um método chama um método depreciado ou executa uma conversão do tipo inseguro, o compilador gera um aviso. Podemos adicionar a este método
@Suppresswarnings Anotação para suprimir avisos de geração do compilador.
NOTA: Use a anotação @suppresswarnings e adote o princípio da proximidade. Por exemplo, se um método tiver um aviso, tentamos usar o @suppresswarnings para anotar esse método, em vez de anotar a classe em que o método está localizado. Embora ambos possam suprimir o compilador de gerar avisos, quanto menor o escopo, melhor, porque o escopo é maior, o que não é propício a descobrir informações de aviso de outros métodos nesta classe.
Exemplo de uso
@Suppresswarningspublic void Methodwithwarning () {}Crie suas próprias anotações
Em Java, podemos criar nossas próprias anotações, anotações e classes, e os arquivos de interface são definidos em nosso próprio arquivo. do seguinte modo
@interface myannotation {string value (); String name (); int age (); String [] newNames ();}O código acima define uma anotação chamada Myannotation, que possui 4 elementos. Novamente, a palavra -chave @interface é usada para dizer ao compilador Java que esta é uma anotação.
Se você olhar de perto, descobrirá que a definição de elementos de anotação é muito semelhante ao método da interface. Esses elementos têm tipos e nomes. Esses tipos podem ser
A seguir estão as anotações personalizadas do aplicativo
@Myannotation (value = "123", name = "Jakob", idade = 37, newNames = {"jenkov", "Peterson"}) classe pública myclass {}Observe que precisamos definir valores para todos os elementos de anotação e ninguém pode estar faltando.
Elemento de anotação valor padrão
Para elementos nas anotações, podemos definir valores padrão para eles, usando o método
@interface myannotation {string value () padrão ""; String name (); int age (); String [] newNames ();}No código acima, definimos o valor padrão do elemento de valor em uma string vazia. Quando o estivermos usando, não podemos definir o valor, ou seja, que o valor use o valor padrão da sequência vazia. Use código de amostra
@Myannotation (name = "Jakob", idade = 37, newNames = {"Jenkov", "Peterson"}) classe pública myclass {}@Retenção
@Retention é uma anotação usada para modificar a anotação. Usando esta anotação, podemos fazê -lo.
Controle se as anotações são gravadas no arquivo de classe para controlar se as anotações no arquivo de classe são visíveis em tempo de execução
O controle é simples, basta usar uma das três estratégias a seguir.
RetentionPolicy.Source indica que a anotação existe apenas no código -fonte, não existe. Class. Class e não pode ser visível durante o tempo de execução. As anotações comuns são @Override, @suppresswarnings.
RetentionPolicy.class Esta é a política de retenção de anotação padrão. Sob essa estratégia, as anotações existirão com o arquivo .class, mas não podem ser acessadas em tempo de execução. Geralmente, essa estratégia de anotação é usada para operar em algum nível de bytecode.
RetentionPolicy.Runtime pode ser acessado em tempo de execução sob esta política. Muitas vezes, fazemos algo em combinação com a reflexão.
Exemplo de uso de @retention
importar java.lang.annotation.retention; importar java.lang.annotation.retEntionPolicy; @retention (retentionpolicy.runtime) @interface myannotation {string value () padrão "";}@Alvo
Usando a anotação @target, podemos definir quais elementos Java podem ser modificados por anotações personalizadas. Exemplo simples
importar java.lang.annotation.ElementType; importar java.lang.annotation.target; @target ({elementType.method}) public @interface myannotation {string value ();}O código acima mostra que a anotação Myannotation pode apenas modificar o método.
@Target pode selecionar os valores dos parâmetros da seguinte maneira
@Irited
Se você deseja que uma aula e sua subclasse contenham uma anotação, você pode usar o @Inerited para modificar esta anotação.
java.lang.annotation.inseited@inheradopublic @interface myannotation {} 12@myannotationpublic classe mysuperclass {...} 1 Classe MySubclass estende mysuperclass {...}O significado geral do código acima é
1. Use @inherado para modificar a anotação
2. Anotação de Mysuperclass usando Myannotation
3. Implemente uma classe MySubclass herda da Mysuperclass
Através das etapas acima, o MySubclass também tem anotação de Myannotation.
Estes são alguns conceitos básicos sobre as anotações em Java.
O exposto acima é a classificação de anotações em Java. Continuaremos a adicionar informações relevantes no futuro. Obrigado pelo seu apoio a este site!