SLT0905V - Programmation orientée objets

Programmation pour le TAL

Correction Java - objets géométriques

question 3
Lorsqu'on exécute initialement la méthode main(), les deux dernières lignes qui s'affichent dans la console sont :
```
Seg1 [Segment: ep1=anonymous [MobilePoint (x = 2, y = 5)], ep2=anonymous [MobilePoint (x = 1, y = 8)]]
Seg1 [Segment: ep1=A [MobilePoint (x = 2, y = 5)], ep2=B [MobilePoint (x = 1, y = 8)]]
```
Elles correspondent aux instructions :
```
System.out.println(sgmt.toString());
sgmt.getEndPoint1().setObjName("A");
sgmt.getEndPoint2().setObjName("B");
System.out.println(sgmt.toString());
```
qui invoquent la métode toString() de la classe Segment.
Si on commente la méthode toString() de cette classe, on obtient l'affichage suivant à la place :
```
Seg1 [GeomObj]
Seg1 [GeomObj]
```
Il s'agit de l'affichage produit par l'exécution de la méthode toString() de la classe GeomObject. Dans les deux cas (avec ou sans commentaires), la classe Segment hérite de la classe GeomObject, donc de ses membres et méthodes. La méthode toString() de la classe Segment redéfinit celle de la classe GeomObject. C'est cette méthode redéfinie qui s'exécute lorsqu'on invoque toString() sur une instance de Segment. Mais lorsqu'elle est commentée, c'est la méthode héritée de GeomObject qui s'exécute.

Note : si vous tentez à nouveau l'expérience en laissant la méthode toString() de Segment commentée, et que vous commentez également la méthode toString() de la classe GeomObject, que se passe-t-il ?
Logiquement, on invoque une méthode qui n'existe ni dans Segment, ni dans sa classe mère GeomObject. Cela devrait donc provoquer une erreur (The method toString() is undefined for the type Segment) et Eclipse ne devrait même pas permettre d'exécuter la méthode main(). Ce n'est pas le cas. Non seulement, aucune erreur n'est signalée, mais la méthode toString() produit une chaîne de caractère, du type "sajous.litl.geom.Segment@49476842".
Explication : il existe en Java un classe Object dont hérite implicitement toute classe que vous créez, si vous ne la faites pas dériver d'une autre classe (par le mot-clé extends). Voir le cours sur la classe Object. Dans cette classe est définie la méthode dont la signature est :
```
public String toString()
```
On peut donc invoquer toString () sur tout objet Java. Si la méthode est redéfinie (comme c'est le cas initialement pour Segment), c'est la méthode redéfinie qui s'exécute. Sinon, c'est celle de la classe Object.
Vous pouvez consulter la documentation de la classe Object de l'API : cherchez la class Object (sans italique) dans l'onglet en bas à gauche.
Méthode translate() dans la classe Segment.
Déplacer un segment, c'est déplacer ses deux extrémités. On peut être tenté d'implémenter la méthode ainsi :
```
public void translate (int dx, int dy)
{
        getEndPoint1().setX (getEndPoint1().getX() + dx);
        getEndPoint1().setY (getEndPoint1().getY() + dy);
        getEndPoint2().setX (getEndPoint2().getX() + dx);
	getEndPoint2().setY (getEndPoint2().getY() + dy);
}
```
Ça n'est pas faux. Mais on refait le travail qui est déjà fait dans la classe MobilePoint. Une instance de MobilePoint "sait" se déplacer : la classe est déjà pourvue d'une méthode translate(). Dans Segment, pour "déplacer les deux extrémités", il suffit de "demander" à ces extrémités de se déplacer. :
```
public void translate (int dx, int dy)
{
        getEndPoint1().translate (dx);
	getEndPoint2().translate (dy);
}
```
Note : il s'agit du même principe que lorsqu'on voulait appliquer une effet aux couleurs des briques et des figurines. On avait initialement implémenté une méthode highlight() dans chacune des classes, avec les instructions :
```
red = 255 - red;
green = 255 - green;
blue = 255 - blue;
```
Puis, lorsqu'on a créé la classe Color, on a remplacé ces instructions par color.highlight (). Tout ce qui concernait la gestion de la couleur était géré dans cette classe.
Classes Circle, Segment et TestGeomObjects : geomCorrectionSeance5.zip
Réponse aux questions
- égalité d'objets, valeur null :
  L'opérateur == permet de comparer des variables correspondant à es types primitfs ou à des objets. Appliqué à deux variables de type primitif, il compare leurs valeurs et renvoie true si ces valeurs sont identiques.
```
    int entier1 = 3;
    int entier2 = 2;
    System.out.println (entier1 == entier2); // affiche false
    entier2++;
    System.out.println (entier1 == entier2); // affiche true
```
  entier1 et entier2 sont deux variables différentes qui peuvent avoir ou non la même valeur.
  Appliqué à deux variables qui correspondent à des objets, l'opérateur == renvoie true si ces deux variables référencent le même objet et false si les variables référencent deux objets différents, même si tous leurs champs ont les mêmes valeurs, cf. ci-dessous. Lorsqu'on déclare une variable, par exemple de type MobilePoint, sans lui affecter d'objet (d'instance de cette classe)
```
    MobilePoint mp1;
```
  mp1 est destiné à recevoir la référence (l'adresse mémoire) vers un objet. Mais initialement, mp1 vaut null. Le test (mp1 == null) vaut true. Si on écrit
```
    mp1.translate (-1, 3);
```
  on obtient une "NullPointerException" : on a tenté d'invoquer une méthode sur une référence qui ne pointe vers aucun objet. Si on écrit
```
    MobilePoint mp1 = new MobilePoint (2, 4);
```
  mp1 n'est pas null. On peut invoquer des méthodes sur mp1. Si on écrit ensuite
```
    MobilePoint mp2 = mp1;
```
  mp2 n'est pas null, il référence le même objet que mp1. Si ont fait afficher la valeur de (mp2 == mp1)
```
    System.out.println(mp2 == mp1);
```
  on obtient true. Si on déplace mp2
```
    mp2.translate (-2, 5);
```
  et qu'on fait afficher les coordonnées de mp1, elles seront identiques à celles de mp2 (0, 9), puisqu'il s'agit du même objet. Si en revanche on écrit
```
    MobilePoint mp2 = new MobilePoint (2, 4);
```
  et que l'on affiche à nouveau la valeur de (mp2 == mp1)
```
    System.out.println(mp2 == mp1);
```
  on obtient false : mp1 et mp2 pointent vers deux objets différents, même s'ils ont les mêmes coordonnées. Si on déplace mp1
```
    mp1.translate (-2, 5);
```
  mp1 aura les coordonnées (0, 9), mais mp2 est un autre objet. Il gardera ses coordonnées (2, 4).
  
  Voir la présentation "visibilité des variables, valeurs et références" de la séance 4 ainsi que le début de la section 4 (Affectation et comparaison d'objets) jusqu'à la section 4.3 du chapitre 6 du livre "Programmer en Java".

[ Retour page U.E. ]

[ Mention légale ]