En Java, l'annotation est introduite dans Java 5 et est utilisée pour décrire les informations méta-informations du code Java. Habituellement, les annotations n'affecteront pas directement l'exécution du code, bien que certaines annotations puissent être utilisées pour affecter l'exécution du code.
Ce qui peut être fait avec les annotations
Les annotations en Java jouent généralement les rôles suivants
dans
Bases d'annotation
Une simple annotation Java est similaire à @entity. Où @ signifie dire au compilateur qu'il s'agit d'une annotation. L'entité est le nom de l'annotation. Habituellement dans un fichier, la méthode d'écriture est la suivante
entité publique @interface {
}
Éléments d'annotation
Les annotations Java peuvent utiliser des éléments pour définir certaines valeurs, et les éléments des annotations sont similaires aux attributs ou paramètres. Exemple de code pour définir des éléments contenant de l'annotation
entité publique @interface {
String TableName ();
}
Exemple de code à l'aide d'éléments contenant de l'annotation
@Entity (tablename = "véhicules")
Le nom de l'élément de l'annotation ci-dessus est le nom de table et l'ensemble de valeur est des véhicules. Les annotations sans éléments ne nécessitent pas de parenthèses.
Si l'annotation contient plusieurs éléments, la méthode d'utilisation est la suivante
@Entity (tablename = "véhicules", primaireyy = "id")
Si l'annotation n'a qu'un seul élément, nous l'écrivons généralement comme ça
@InsertNew (value = "Oui")
Mais dans ce cas, si et seulement si le nom de l'élément est de valeur, nous pouvons également l'abréger, c'est-à-dire qu'il n'est pas nécessaire de remplir la valeur du nom de l'élément, l'effet est le suivant
@InsertNew ("Oui")
Utilisation de l'annotation
Les annotations peuvent être utilisées pour modifier ces éléments dans le code
Un exemple complet d'utilisation est le suivant
@EntityPublic classe véhicule {@Persistent Protected String VehicLename = NULL; @Getter public String getVeHicLename () {return this.veHicLename; } public void SetveHicLename (@Optional VehicLename) {this.veHicLename = VehicLename; } public list addvehiclenametolist (list names) {@Optional list localNames = noms; if (localNames == null) {localNames = new ArrayList (); } localNames.add (getVeHicLename ()); Retour localNames; }}Annotations Java intégrées
Il existe trois annotations intégrées en Java qui sont utilisées pour fournir des instructions pour le compilateur. Ils sont
@Deprecated
Peut être utilisé pour marquer des classes, des méthodes et des propriétés.
Si les trois éléments ci-dessus ne sont plus utilisés, utilisez l'annotation @deprecated. Si le code utilise la classe, la méthode ou la propriété de l'annotation @Deprecated, le compilateur vous avertira.
@Deprecated est très simple à utiliser, comme suit: Annotation d'une classe obsolète.
@DeprecatedPublic classe MyComponent {}Lorsque nous utilisons l'annotation @Deprecated, il est recommandé d'utiliser le symbole Javadoc @Deprecated correspondant en conjonction avec lui et d'expliquer pourquoi cette classe, méthode ou propriété est obsolète et quelle est l'alternative.
@DepreCated / ** @Deprecated Cette classe est pleine de bogues. Utilisez MyNewComponent à la place. * / Classe publique MyComponent {}@Outrepasser
L'annotation @Override est utilisée pour modifier la méthode de réécriture de la classe parent. Si une méthode qui ne remplace pas la classe parent utilise cette annotation, le compilateur invitera une erreur.
En fait, @overide n'est pas nécessaire pour remplacer les méthodes de la classe des parents ou de l'interface dans une sous-classe. Cependant, il est toujours recommandé d'utiliser cette annotation. Dans certains cas, en supposant que vous modifiez le nom de la méthode de la classe parent, la méthode de sous-classe qui a été réécrite avant ne sera plus réécrite. Sans @overide, vous ne remarquerez pas la méthode de cette sous-classe. Avec cette modification d'annotation, le compilateur vous invitera à ces informations.
Exemples d'utilisation de l'annotation de remplacement
classe publique MySuperclass {public void dothething () {System.out.println ("faire la chose"); }} classe publique MySubClass étend MySuperclass {@Override public void dothething () {System.out.println ("faire différemment"); }}@Suppresswarnings
@SuppressWarnings est utilisé pour supprimer le compilateur de la génération de messages d'avertissement.
Les éléments qui peuvent être modifiés sont des classes, des méthodes, des paramètres de méthode, des attributs et des variables locales
Scénario d'utilisation: Lorsqu'une méthode appelle une méthode obsolète ou effectue une conversion de type dangereuse, le compilateur générera un avertissement. Nous pouvons ajouter à cette méthode
@Suppresswarnings Annotation pour supprimer les avertissements de génération de compilateurs.
Remarque: Utilisez l'annotation @SuppressWarnings et adoptez le principe de la proximité. Par exemple, si une méthode a un avertissement, nous essayons d'utiliser @SuppressWarnings pour annoter cette méthode, plutôt que d'annoter la classe où se trouve la méthode. Bien que les deux puissent supprimer le compilateur de générer des avertissements, plus la portée est petite, mieux c'est, car la portée est plus grande, ce qui n'est pas propice à la découverte d'informations d'avertissement d'autres méthodes sous cette classe.
Exemple d'utilisation
@SuppressWarningsPublic void MethodWithWarning () {}Créez vos propres annotations
En Java, nous pouvons créer nos propres annotations, annotations et classes, et les fichiers d'interface sont définis dans notre propre fichier. comme suit
@Interface Myannotation {String Value (); String name (); int age (); String [] newNames ();}Le code ci-dessus définit une annotation appelée myannotation, qui a 4 éléments. Encore une fois, le mot clé @Interface est utilisé pour dire au compilateur Java qu'il s'agit d'une annotation.
Si vous regardez attentivement, vous constaterez que la définition des éléments d'annotation est très similaire à la méthode d'interface. Ces éléments ont des types et des noms. Ces types peuvent être
Voici les annotations personnalisées de l'application
@Myannotation (value = "123", name = "jakob", age = 37, newnames = {"jenkov", "peterson"}) public class myclass {}Notez que nous devons définir des valeurs pour tous les éléments d'annotation et que personne ne peut manquer.
Valeur par défaut de l'élément d'annotation
Pour les éléments des annotations, nous pouvons définir des valeurs par défaut pour eux, en utilisant la méthode
@Interface Myannotation {String Value () Default ""; String name (); int age (); String [] newNames ();}Dans le code ci-dessus, nous définissons la valeur par défaut de l'élément de valeur sur une chaîne vide. Lorsque nous l'utilisons, nous ne pouvons pas définir la valeur, c'est-à-dire que la valeur utilise la valeur par défaut de la chaîne vide. Utiliser un exemple de code
@Myannotation (name = "jakob", age = 37, newnames = {"jenkov", "peterson"}) public class myclass {}@Rétention
@Retention est une annotation utilisée pour modifier l'annotation. En utilisant cette annotation, nous pouvons le faire.
Contrôlez si les annotations sont écrites dans le fichier de classe pour contrôler si les annotations dans le fichier de classe sont visibles lors de l'exécution
Le contrôle est simple, utilisez simplement l'une des trois stratégies suivantes.
RetentionPolicy.Source indique que l'annotation existe uniquement dans le code source, n'existe pas de fichiers. Classe et ne peut pas être visible pendant l'exécution. Les annotations courantes sont @Override, @SuppressWarnings.
RetenderPolicy.class Il s'agit de la politique de rétention d'annotation par défaut. Dans le cadre de cette stratégie, les annotations existeront avec le fichier .class, mais ne sont pas accessibles au moment de l'exécution. Habituellement, cette stratégie d'annotation est utilisée pour fonctionner au niveau du bytecode.
RetentionPolicy.runtime est accessible lors de l'exécution dans le cadre de cette politique. Souvent, nous faisons quelque chose en combinaison avec la réflexion.
Exemple d'utilisation de @retention
Importer java.lang.annotation.retention; import java.lang.annotation.retentionPolicy; @retention (retentionPolicy.runtime) @Interface Myannotation {String Value () Default "";}@Cible
En utilisant l'annotation @target, nous pouvons définir les éléments Java peut être modifié par des annotations personnalisées. Exemple simple
import java.lang.annotation.elementType; import java.lang.annotation.target; @target ({elementType.Method}) public @Interface Myannotation {String Value ();}Le code ci-dessus montre que l'annotation de myannotation ne peut que modifier la méthode.
@Target peut sélectionner les valeurs des paramètres comme suit
@Hérité
Si vous voulez qu'une classe et sa sous-classe contiennent une annotation, vous pouvez utiliser @Inherited pour modifier cette annotation.
java.lang.annotation.inherited@inheritedpublic @interface myannotation {} 12 @ MyannotationPublic class MySuperclass {...} 1Public class MySubClass étend MySuperclass {...}La signification générale du code ci-dessus est
1. Utilisez @inherited pour modifier l'annotation
2. Annotation de MySuperclass à l'aide de la myannotation
3. Implémentez une classe MySubClass hérite de MySuperclass
Grâce aux étapes ci-dessus, MySubClass a également une annotation de myannotation.
Ce sont quelques concepts de base sur les annotations en Java.
Ce qui précède est le tri des annotations en Java. Nous continuerons d'ajouter des informations pertinentes à l'avenir. Merci pour votre soutien à ce site!