Annotations Java

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

Quels sont leurs usages typiques?

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

Les annotations sont principalement utilisées par le code qui inspecte un autre code. Ils sont souvent utilisés pour modifier (c'est-à-dire décorer ou encapsuler) des classes existantes au moment de l'exécution afin de changer leur comportement. Les frameworks tels que JUnit et Hibernate utilisent 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.

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

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

Leur utilisation est assez diversifiée. Un exemple typique de Java @Overriden'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 des informations de (dé) sérialisation pour les classes, déterminer la 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.

/ EDIT: les attributs sur les classes sont comparables aux interfaces de balises (comme Serializable en Java). Cependant, les directives de codage .NET indiquent de ne pas utiliser les interfaces de balises. En outre, 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, l' @Testannotation indique à JUnit que la flatfileMissingméthode est un test qui doit être exécuté et que le résultat attendu est un jeté IOException. Ainsi, lorsque vous exécutez vos tests, cette méthode sera appelée et le test réussira ou échouera selon que un IOExceptionest lancé.

Java dispose également de l'outil de traitement des annotations (apt) qui permet non seulement de créer des annotations, mais également de décider comment ces annotations fonctionnent sur le code source.

Voici 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 construction, et je les utilise également pour un cadre de message d'erreur (pas encore publié - il faut clarifier 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é. En plus des annotations Java, les programmes Java ont une abondante documentation informelle qui est généralement contenue 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'annotations 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 appropriée par les outils de traitement.

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

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

Les annotations en ce qui concerne EJB sont connues pour choisir une approche middleware implicite plutôt qu'une approche middleware explicite, lorsque vous utilisez une annotation, vous personnalisez exactement ce dont vous avez besoin de l'API, par exemple, vous devez appeler la méthode de transaction pour un virement 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
}

lorsque vous utilisez Annotation, votre code ne contient aucun appel d'API encombrant pour utiliser les services middleware. 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
}