Sun certification et pièges java.

Voila un petit moment que mon blog est resté au point mort. L’explication à cela est du à :

• 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…