• la fin de ma mission chez Groupama début juillet.
• le passage de la certification SCJP dans la foulée.

Je vais faire le bilan de la certification SCJP dans mon prochain post donc je ne vais pas plus m’attarder sur celle-ci maintenant. Par contre le fait d’avoir travailler la certification m’a permis de découvrir certaines subtilités du langage java. Si vous trouvez la réponse tout de suite aux questions ci-dessous c’est bon, la certif SCJP est dans votre poche, sinon au boulot…

Override & Overload

Connaissez-vous bien le fonctionnement de la surcharge (Override) et de la redéfinition (Overload) ? Quel est donc le résultat de ce bout de code :

1. class Animal{
2.   public void mange(Animal a){
3.     System.out.println("un");
4.   }
5. }
6. class Chat  extends Animal{
7.   public void mange(Animal a){
8.     System.out.println("deux");
9.   }
10.   public void mange(Chat a){
11.     System.out.println("trois");
12.   }
13.   public static void main(String[] args) {
14.     Animal animal = new Chat();
15.     animal.mange(animal);
16.   }
17. }

Interface

Ce bout de code est plus que trivial. Il n’y a aucun problème naturellement…

1. interface MyInterface{
2.   void myMethod();
3. }
4. class MyClass implements MyInterface{
5.   void myMethod() {}
6. }

Constructeurs

Toujours trivial, toujours sans problème ?

1. class Constructeur {
2.   public Constructeur(String s) {}
3. }
4. class Const2 extends Constructeur{
5.   public Const2(String s){}
6. }

float

Enrobé dans 10 lignes de codes, ce code bidon peut se révéler très piégeur :

1. float f = 1/2;
2. System.out.println("Mon QI : "+ f*2);

Autoboxing et widening

Tout s’explique, même ceci. Comment justifierez-vous le choix de la méthode à appeler ?

1. public static void coucou(Float f){
2.   System.out.println("Float");
3. }
4. public static void coucou(double f){
5.   System.out.println("double");
6. }
7. public static void main(String[] args) {
8.   float f = 0;
9.   coucou(f);
10. }

Il y en a bien d’autres, mais celles-ci sont déjà représentatives de l’esprit de la certification.

Réponses :

1) le résultat est … « deux » !
Le principe est : Overload est définit à la compilation, Override à l’exécution. Donc lors de la compilation le compilateur ne sait uniquement que notre « animal » est un Animal mais sans en savoir plus. Donc suivant le principe il va éliminer du choix des méthodes la numéro trois car elle prend en paramètre un Chat. Lors de l’exécution par contre la JVM sait que notre variable est un Chat, donc elle va choisir la méthode numéro deux qui est définit dans la classe Chat. C’est aussi simple que cela.

2) Ca ne compile pas bien évidemment.
Le problème vient du fait que les méthodes est variables dans une interface sont typées par défaut, même si vous ne le mettez pas. Le type par défaut d’une méthode est public. Donc quand on l’implémente en ne mettant rien on lui attribut le typage défault qui est plus restrictif que public est donc interdit…
Merci à Eclipse de l’avoir fait pour nous depuis tant d’années.
Le type des variables est par défaut lui public static final.3) Idem, ça compile pas.

3) Idem, ça compile pas.
Le problème vient de l’appel au constructeur par défaut. Ce qu’on appelle un constructeur par défaut est un constructeur sans argument qui est automatiquement rajouté à la compilation … si la classe ne définit pas déjà un autre constructeur. Ici donc, aucun constructeur par défaut n’est inséré car on en définit un dans chaque classe.
Le problème provient du fait que la première ligne de chaque constructeur doit contenir une référence vers un autre constructeur de la classe (this(…)) ou de la classe mère (super(…)). Si aucun appel de ce style n’est positionné sur la première ligne alors le compilateur ajoute tout seul : « super() ; »
C’est ce qui se passe sur l’exemple ci-dessus et qui provoque donc une erreur de compilation car le constructeur sans paramètres n’existe pas.

4) Le résultat est évidemment 0.
Un chiffre est considéré par le compilateur comme un int. Le résultat d’un int divisé par un int produit donc un int, le résultat est donc 0.

5) Le résultat est bien sûre « double ». On peut en effet utiliser en java la technique du « widening » qui permet ici de transformer notre float en double (no problem : un double peut contenir un float). On peut aussi depuis java 1.5 utiliser l’autoboxing, l’appel utilisant un « Float » est donc parfaitement valable également donc. L’autoboxing paraitrait plus logique, cependant c’est bien la méthode avec un double qui est appelé pour des besoins de compatibilité avec les versions de java antérieur. Too bad…

• La première est l’utilisation des regex dans l’éditeur « rechercher/remplacer ». Comment peut-on gagner beaucoup de temps et s’éviter un boulot à la con ?
• La seconde est l’utilisation des « tasks » (TODO, FIXME, …). Comment bien les utiliser, comment créer les siennes ?

Astuce 1 : gagnez du temps, utilisez les regex

Il n’y a rien de plus chiant quand l’on code que de faire des séquences répétitives comme par exemple : (appui sur la touche « fin », « ; », « flèche du bas » ) * 20 …

Plutôt que d’effectuer des tâches répétitives, je préfère bien souvent plutôt utiliser le temps que je passe d’habitude à effectuer ceci et ensuite à corriger les erreurs (qui s’insèrent souvent lorsque l’on fait ce genre de chose) par plutôt chercher une expression régulière qui effectuera ce boulôt.

Eclipse propose un support basique mais assez efficace des regex dans l’écran « Rechercher/Remplacer » (raccourci ctr+F). Pour celà, il suffit de cliquer sur la checkbox « Regular Expression ».

La syntaxe est identique aux expressions régulières java : « . » pour tout caractère, « * » pour répéter 0 ou n fois, « () » pour capturer un groupe, « [\w] pour récupérer uniquement les caractères de mots, etc…

Pour récupérer les groupes que l’on a capturé, on utilise dans la partie « replace with » les expressions $1 pour le premier groupe, $2 pour le suivant, etc…

Un petit exemple bateau :

A partir de l’exemple ci dessus, imaginez que l’on veuille vérifier que toutes les variables de classes ne soient pas nulles.

On copie colle la définition des variables dans notre méthode (voir image1).

On recherche l’expression : « Private String ([\w]*) = «  »; »

Que l’on remplace par exemple par : « if($1 != null && !($1).equals(«  »)){}

Ce qui produit comme résultat :

Marvellous!

Astuce 2 : n’oubliez rien, utilisez les tasks

Je suis un fan des TODO/FIXME. C’est à dire que plutôt que d’écrire sur trois milles post-it les choses restant à faire, ou à corriger ou bien d’utiliser l’éternel « Nouveau document texte.txt » posé sur le bureau. Je préfère que tous ces éléments soient directement intégrés dans le code.

La vue des tasks se présente comme suit :

On remarque tout de suite que l’avantage est que les tâches sont localisés à l’endroit ou elle doivent être. Un clic et on s’y rend. De plus, elle sont priorisable (high, normal ou low).

On peut de plus créer ses propres tâches personnalisées. Pour cela, se rendre dans les préférences -> Java -> Compiler -> tasks tags :

Le seul inconvénient, est que l’on sera le seul dans l’équipe à les voir si les autres ne rajoutent pas ces mêmes tâches. Dans l’exemple, j’ai rajouté une tâche NAT avec une priorité haute. J’ai aussi pour habitude de descendre la tâche XXX en priorité faible.

Un autre truc cool avec les tâches est la gestion facile des filtres. Ces filtres ressemblent pas mal à ceux de la vue « Errors » :

Ce qui est intéressant est de placer le filtre sur uniquement la classe ouverte lorsque l’on code (radio « On selected Element Only ») et éventuellement de filter sur les priorités. Quand on veux ensuite faire du refactoring global on enlève ces filtres, pratique!

Bonus :

En petit bonus aujourd’hui, je vous propose cet article que j’ai découvert hier, présentant diverses astuces Eclipse.

Une astuce utile à laquelle je n’avais pas réfléchi et de remplacer dans les templates la génération du try/catch pour insérer dans le catch :

logger.severe(« Exception caught:  » + ${exception_var});

Tout bête, mais pratique.

C’est tout pour aujourd’hui. En espérant vous avoir fait gagner 5 minutes sur votre prochaine journée

Je n’utilise que certaines de ces librairies par habitude, mais je me rend compte de plus en plus souvent que cela vaut le coup d’aller fréquemment y faire un saut pour éviter de réinventer la roue à chaque fois…

Ce coup ci je viens de retomber sur l’API commons lang qui vise à étoffer le comportement de java.lang. Elle contient quantité de classes utilitaires qui peuvent être utilisées sur énormément de projet, d’ailleurs je pense que beaucoup de projets réécrivent en partie ces classes (vécu)…

Voici un petit tour rapide de ce que j’ai découvert d’intéressant :

• La classe StringUtils avec notamment la méthode IsEmpty() qui permet de remplacer monString != null && !(«  »).equals(monString)
• HashCodeBuilder qui permet de coder un bon hashCode sans avoir à ressortir à chaque fois java efficace de Joshua Blosch (que je recommande)
• ExceptionsUtils.getStackTrace(e) qui permet d’écrire la stackTrace dans une log par exemple ce que ne permet pas e.printStackTrace()
• DateUtils qui contient des méthodes tels : addYear(), addMonth(), addMinute(), …
• EqualsBuilder pour aider à redéfinir la méthode equals
• NumberUtils avec par exemple toInt(str), toFloat(str), …
• …

Mon conseil du jour est donc : gagnons du temps et refouillons un peu dans les commons