janvier
2007
Un article de vbrabant
Le JDK a été rendu open source quelque part en novembre.
Il n’aura pas fallu attendre longtemps finalement pour voir les premiers compilateurs Java modifiés.
Mais je dois dire que cela n’est pas pour me déplaire.
En effet, loin de vouloir créer des forks du compilateur Java, Rémi Forax nous propose sur son blog des prototypes de compilateur Java qui pourraient être réutilisé dans le futur JDK.
Ainsi, il nous propose une modification du compilateur qui doit permettre la déclaration de properties.
Mais je me demande tout de même pourquoi il n’a pas utilisé les annotations pour cela.
Il me semble que @Property serait bien plus puissant dans ce cas. Car cela nous permettrait de passer des paramètres à l’annotation, pour indiquer qu’il ne faudrait créer que le getter par exemple. Ou pour indiquer quelle méthode jouera le rôle du getter ou du setter.
Par exemple
@Property() String x;
serait équivalent à
public void setX(String x) {
this.x = x;
}
public String getX() {
return x;
}
tandis que
@Property(getter="getType") String x;
serait équivalent à
public String getType() {
return x;
}
avec en prime la possibilité de dire que fichier des JavaBeans soit généré pour dire que getType est le getter de x
et finalement
@Property(name="type") String x;
correspondrait à
public void setType(String x) {
this.x = x;
}
public String getType() {
return x;
}
Mais bon. Je dis ca, je dis rien. De tout façon, combien d’entre nous se fatigue encore à taper tout ce code ? Les IDE génèrent depuis bien longtemps. Et puis cela va permettre d’exprimer la même chose de 2 façons différentes, et j’aime pas cela.
Mais qui suis-je dans le monde Java pour que ceux qui conçoivent la génération future des compilateurs java se soucient de mon avis. Car en effet, c’est un peu là le problème. On a chacun ses préférences et ses opinions. Difficile d’avoir tout le monde d’accord sur une syntaxe.
2 Commentaires + Ajouter un commentaire
Commentaires récents
Archives
- janvier 2012
- novembre 2010
- février 2009
- janvier 2009
- décembre 2008
- septembre 2008
- août 2008
- décembre 2007
- octobre 2007
- septembre 2007
- juillet 2007
- mai 2007
- avril 2007
- mars 2007
- février 2007
- janvier 2007
- décembre 2006
- novembre 2006
- octobre 2006
- septembre 2006
- août 2006
- juillet 2006
- juin 2006
- mai 2006
- avril 2006
- février 2006
- janvier 2006
- décembre 2005
- novembre 2005
- octobre 2005
- septembre 2005
- août 2005
- juillet 2005
- juin 2005
- mai 2005
- avril 2005
Catégories
- Certification
- Défis
- Devoxx
- Devoxx 2008
- Devoxx 2010
- Devoxx France 2012
- Divers
- Événements Java
- Fiches
- Hardware
- In English
- Java
- JavaDay 2006
- JavaFX
- JavaOne 2005
- JavaOne 2006
- JavaOne 2007
- Javapolis 2005
- Javapolis 2006
- Javapolis 2007
- JBoss
- Livres
- Mac
- NetBeans
- OpenJDK
- Pensée
- Performance
- Perles
- Sun Tech Days Paris 2007
- Traduction
En ce qui concerne les annotations, mon sentiment est que c’est un outil pratique, mais qu’il ne faudrait pas mettre à toute les sauces « parce que c’est la mode ».
Sinon je trouve que ce qu’a fait Rémi Forax est intéressant.
>> De tout façon, combien d’entre nous se fatigue encore à taper tout ce code ? Les IDE génèrent depuis bien longtemps.
Oui… mais le code en reste quand même moins lisible. Lorsqu’on commence à avoir un certain nombre d’attribut, cela devient un peu brouillon malgré l’EDI et l’éventuel folding… Tandis qu’avec une solution comme celle là on peut faire le tour en quelques lignes…
Une tel syntaxe aurait le mérite de rendre le tout plus lisible, car toute les infos seraient regroupé sur une ou deux lignes de déclaration…
>> Et puis cela va permettre d’exprimer la même chose de 2 façons différentes, et j’aime pas cela.
Mais cela permet à chacun de faire selon ses gouts
Toutefois je n’aime pas trop ce prototype :
est remplacé par l’appel au getter/setter selon le cas :
. C’est à la fois une bonne idée car cela facilite la lecture du code, et une mauvaise idée car cela nuit à la compréhension : L’opérateur ‘.’ sur un attribut aboutira à un accès direct ou un appel au getter ? Rien n’est plus aussi sûr. Je préfère l’utilisation de l’opérateur -> (ou d’un autre opérateur) qui permettrait d’éviter les doutes…
Même si je pense que l’idée général est plutôt pas mal…
a++
PS : Quand à l’utilisation d’une annotation, j’y ai pensé également, mais il me semble que les annotations ne sont pas supposé modifié la sémantique de la classe sur laquelle elles s’appliquent… D’ailleurs même avec l’Annotation Processor ce n’est pas possible (on peut simplement générer d’autre classe).