•  09-06-2019
  •  | 
  •  

Question

A quoi servent les annotations en Java ?J'en ai cette idée floue comme quelque part entre un commentaire et le code réel.Affectent-ils le programme au moment de l’exécution ?

Quelles sont leurs utilisations typiques ?

Sont-ils uniques à Java ?Existe-t-il un équivalent C++ ?

Était-ce utile?

La solution

Les annotations sont principalement utilisées par le code qui inspecte un autre code.Ils sont souvent utilisés pour modifier (c.-à-d.décoration ou emballage) des classes existantes au moment de l'exécution pour modifier leur comportement.Des cadres tels que JUnit et Hiberner utilisez des annotations pour minimiser la quantité de code que vous devez écrire vous-même pour utiliser les frameworks.

Oracle a une bonne explication du concept et de sa signification en Java sur leur site.

Autres conseils

De plus, sont-ils uniques à Java, existe-t-il un équivalent C++ ?

Non, mais VB et C# ont les attributs qui sont la même chose.

Leur utilisation est assez diversifiée.Un exemple Java typique, @Override n'a aucun effet sur le code mais il peut être utilisé par le compilateur pour générer un avertissement (ou une erreur) si la méthode décorée ne remplace pas réellement une autre méthode.De même, les méthodes peuvent être marquées comme obsolètes.

Ensuite, il y a la réflexion.Lorsque vous reflètez un type de classe dans votre code, vous pouvez accéder aux attributs et agir en fonction des informations qui s'y trouvent.Je ne connais aucun exemple en Java mais en .NET, cela est utilisé par le compilateur pour générer (dé)sérialisation informations pour les cours, déterminer le disposition de la mémoire des structures et déclarer les importations de fonctions à partir de bibliothèques héritées (entre autres).Ils contrôlent également le fonctionnement du concepteur de formulaires IDE.

/MODIFIER:Les attributs des classes sont comparables aux interfaces de balises (comme Sérialisable en Java).Cependant, les directives de codage .NET indiquent de ne pas utiliser d'interfaces de balises.De plus, ils ne fonctionnent qu’au niveau de la classe, pas au niveau de la méthode.

Anders donne un bon résumé, et voici un exemple d'annotation JUnit

@Test(expected=IOException.class)
public void flatfileMissing() throws IOException {
    readFlatFile("testfiles"+separator+"flatfile_doesnotexist.dat");
}

Ici le @Test l'annotation indique à JUnit que le flatfileMissing méthode est un test qui doit être exécuté et que le résultat attendu est un test lancé IOException.Ainsi, lorsque vous exécuterez vos tests, cette méthode sera appelée et le test réussira ou échouera selon qu'un IOException Est lancé.

Java dispose également de l'outil de traitement des annotations (apt) dans lequel non seulement vous créez des annotations, mais décidez également comment ces annotations fonctionnent sur le code source.

Ici est une introduction.

Pour voir des choses intéressantes que vous pouvez faire avec les annotations, consultez mes annotations JavaBean et mon processeur d'annotations.

Ils sont parfaits pour générer du code, ajouter des validations supplémentaires lors de votre build, et je les utilise également pour un cadre de messages d'erreur (pas encore publié - besoin d'être clair avec les patrons...).

Par définition littérale, une annotation ajoute des notes à un élément.De même, les annotations Java sont des balises que nous insérons dans le code source pour fournir plus d'informations sur le code.Les annotations Java associent des informations à l'élément de programme annoté.Outre les annotations Java, les programmes Java contiennent de grandes quantités de documentation informelle qui sont généralement contenues dans les commentaires du fichier de code source.Mais les annotations Java sont différentes des commentaires : elles annotent les éléments du programme directement en utilisant des types d'annotation pour décrire la forme des annotations.Les annotations Java présentent les informations de manière standard et structurée afin qu'elles puissent être utilisées de manière conviviale par les outils de traitement.

Pour lire en détail, il y a un joli tutoriel sur Annotations Java

Quand utilisez-vous l'annotation @Override de Java et pourquoi ?Le lien fait référence à une question sur le moment où il faut utiliser l'annotation de remplacement (@override).Cela pourrait aider à mieux comprendre le concept d'annotation.

Annotations En ce qui concerne l'EJB est connue comme le choix de l'approche implicite de la station intermédiaire sur une approche explicite de la station intermédiaire, lorsque vous utilisez l'annotation, vous personnalisez ce dont vous avez exactement besoin à partir de l'API, par exemple, vous devez appeler la méthode de transaction pour un transfert bancaire :sans utiliser d'annotation :le code sera 

transfer(Account account1, Account account2, long amount)    
{
   // 1: Call middleware API to perform a security check
   // 2: Call middleware API to start a transaction
   // 3: Call middleware API to load rows from the database
   // 4: Subtract the balance from one account, add to the other
   // 5: Call middleware API to store rows in the database
   // 6: Call middleware API to end the transaction
}

Lors de l'utilisation de l'annotation, votre code ne contient aucun appel API encombrant pour utiliser les services intermédiaires.Le code est propre et axé sur la logique métier 

transfer(Account account1, Account account2, long amount) 
{
   // 1: Subtract the balance from one account, add to the other
}

Annotations, une forme de métadonnées, fournit des données sur un programme qui ne fait pas partie du programme lui-même.Les annotations n'ont aucun effet direct sur le fonctionnement du code qu'elles annotent.

Les annotations ont plusieurs utilisations, parmi lesquelles :

  • Informations pour le compilateur — Les annotations peuvent être utilisées par le compilateur pour détecter des erreurs ou supprimer des avertissements.
  • Traitement au moment de la compilation et du déploiement — Les outils logiciels peuvent traiter les informations d'annotation pour générer du code, des fichiers XML, etc.
  • Traitement d'exécution — Certaines annotations sont disponibles pour être examinées au moment de l'exécution.

Le champ de visibilité est défini par java.lang.annotation.RetentionPolicy constantes SOURCE, CLASS, et RUNTIME

  • RetentionPolicy.SOURCE:L'annotation serait disponible dans le code source du programme et pourrait être utilisée par le compilateur ou apte pour la génération de code.
  • RetentionPolicy.CLASS:L'annotation serait dans le fichier .class mais elle ne serait pas disponible au moment de l'exécution.Utilisé par les outils de manipulation de code d'octet tels que ASM effectuer les modifications
  • RetentionPolicy.RUNTIME:L'annotation serait disponible dans le fichier .class et au moment de l'exécution, pour inspection via la réflexion Java via getAnnotations().
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top