|
| |
| TUTORIEL JAVA |
 |
|
|
| Les annotations en Java |
| Nouveautés de la version 5.0 du langage, les annotations promettent une conception plus aboutie et une programmation plus propre, au travers de métadonnées.
(03/03/2005) |
  |
Nombreuses sont les nouveautés
apportées par la version Tiger de Java, les plus publicisées
étant les types génériques, la boucle for()
améliorée et les énumérations.
D'autres sont pourtant présentes
et attendues depuis longtemps, dont les annotations. Celles-ci
répondent à un besoin précis des développeurs Java : ajouter
des données sémantiques à leur code, c'est-à-dire des données
expliquant la manière dont certaines autres données doivent être traitées.
Ces "données faisant référence à des données" correspondent à des métadonnées,
et les annotations ont été créées pour elles.
Cela pouvait être accompli précédemment au moyen de JavaDoc,
mais son utilisation requerrait quelques contorsions qui rendaient
l'effort trop laborieux pour être vraiment utile.
Les annotations résolvent le problème de manière efficace, élégante,
et surtout intégrée au langage. Elles permettent, comme on peut
s'y attendre, d'associer
des métadonnées avec des classes, des méthodes, des champs,
des paramètres, des variables, des packages...
La différence avec, par exemple, l'étiquette @deprecated
disponible dans JavaDoc (qui indique que la méthode indiquée
ne doit plus être utilisée) ou encore le modifieur transient
(qui indique qu'un champ doit être ignoré par le système de
sérialisation), est que le développeur peut enfin, grâce aux
annotations, définir ses propres types d'annotations, en plus
d'utiliser ceux déjà proposés par le langage. Il est également
possible d'annoter les annotations, comme le montrent celles
du langage...
Les métadonnées
peuvent être utilisée selon trois objectifs : documentation,
test de compilation, et analyse du code. JavaDoc prend déjà
en charge tout ce qui concerne la documentation, donc les annotations
en tant que nouveautés servent vraiment pour les deux autres
objectifs.
Avec les annotations, le compilateur vérifie
qu'un comportement indiqué dans l'annotation est bien appliqué
dans le code.
Pour ce qui est de l'analyse de code, elles se rendent utiles
en indiquant à un logiciel d'analyse le type attendu en entrée
comme en sortie d'une méthode.
Les annotations de base
Voici les 6 annotations proposées par défaut au sein de J2SE
5.0 :
Deprecated
Indique au compilateur Java qu'il lui faut avertir l'utilisateur
que la classe ou méthode annotée a été dépréciée.
Documented
L'élément annoté dispose d'une documentation utilisable par
JavaDoc (et autres outils assimibles)
Inherited
Permet de spécificer qu'une annotation utilisée sur un élément,
Overrides
La méthode annotée de la classe en cours a pour but le remplacement de
la méthode du même nom établie par une super-classe (directe
ou indirecte).
Rétention
Cette annotation prend un paramètre qui précise son champ d'action
:
Retention.SOURCE : l'annotation
décorée est disponible seulement pour le code source (par défaut).
Retention.CLASS : l'annotation
décorée est disponible pour le code source ainsi que pour le
fichier .class, mais ne peut être chargée par la JVM.
Retention.RUNTIME : disponible
pour le code source, le fichier .class ainsi que la JVM.
 |
Forum |
|
|
Réagissez
dans les forums
de JDN Développeurs
|
Mise en place
La syntaxe des annotations se compose du signe @,
suivi du nom de l'annotation, puis des données entre parenthèses
si elles sont requises, sous la forme nom=valeur.
Elles peuvent donc prendre trois formes : @Annotation,
@Annotation("donnée"), ou @Annotation(variable1="donnée
1", variable2="donnée 2", variable3="donnée 3").
Le code lui-même se place sur la ligne précédent
l'élément annoté :
class Classe extends SuperClasse {
@Overrides
public void action() {
// fait des trucs
}
} |
|
|
|
