refGrilleObjet = new GrilleObjet(3, 5, 15, 25);
refGrilleObjet.longueur |
désigne le champ longueur de l'objet référencé par refGrilleObjet. Cette expression produira une erreur de compilation si le champ longueur est qualifié private dans la définition de la classe.
|
refGrilleObjet.estUnCoin(6,8) |
correspond à une invocation de la méthode estUnCoin sur ce même objet. Elle renverra une valeur de type boolean indiquant si le point (6,8) est un coin de la grille ou non. Là encore, si la méthode est qualifiée private, une erreur de compilation sera rencontrée.
|
Remarque : nous avons mentionné l'existence de la référence this. Il est le plus souvent omis (la référence à l'objet courant est implicite dans la définition des méthodes d'une
classe) mais son usage s'avère nécessaire pour lever l'ambiguïté
provoquée par l'utilisation comme nom de paramètre le nom d'un champ de la
classe. Ainsi, dans la définition du constructeur suivant:
...................
GrilleObjet(int x0, int b, int lg, int ha) {
x0 = this.x0; y0 = b; longueur = lg; hauteur = ha;
}
...................
|
l'utilisation de la référence this permet de distinguer les deux interprétations de l'identificateur x0.
7. Un exemple d'application
On pourra consulter le code complet d'une application utilisant la classe GrilleObjet.
D) Aller plus loin : composer ou dériver des classes
1. Objectif
Nous allons illustrer au travers du même exemple quelques concepts fondateurs de l'approche objet. Nous nous proposons de raffiner la notion de grille telle que nous l'avons définie précédemment. Une grille correspondant à ce nouveau modèle aura tout d'abord tous les attributs d'une grille du
modèle GrilleObjet
précédent, c'est-à-dire qu'on pourra invoquer sur elle les méthodes de cette classe. Mais elle possèdera des attributs supplémentaires
(champs et/ou méthodes) que ne possède pas la classe GrilleObjet qui permettront d'en avoir une représentation graphique telle que celle présentée dans le sujet du partiel et de visualiser des points de la grille et leurs voisins.
Ainsi la grille correspondant à l'objet instancié par l'appel du constructeur GrilleObjet(2,4,12,6), le point de coordonnées (6,7) et ses voisins pourront être visualisés sous une forme assez semblable à la figure suivante:
Nous allons présenter deux approches possibles pour définir cette nouvelle classe. On utilisera, au passage, des fonctions simples de la classe Deug, telles que fillRect et fillCircle qui permettent de visualiser des rectangles et des cercles pleins.
2. Composition et délégation
2.1. Lors de la définition d'une nouvelle classe, il est, heureusement, tout d'abord possible d'encapsuler des variables de type non primitif, c'est-à-dire de définir
des champs de type référence. Le développement d'une nouvelle application peut conduire à la définition de différentes nouvelles classes ou faire appel aux nombreuses classe fournies par les paquetages (packages) standard. Il est ainsi possible de composer des classes.
En partant de cette possibilité, on va définir une nouvelle classe GrilleObjetGraphique qui encapsulera une variable de référence sur la classe GrilleObjet et on ajoutera quelques champs utiles pour le traitement graphique des grilles. On a choisi ici de permettre la visualisation d'un point d'une grille sous la forme d'un carré coloré dont le côté correspond au champ cote et ses voisins par des cercles dont le rayon correspond au champ rayon. Par ailleurs, l'affichage se faisant par pixel, un facteur d'échelle correspondant au champ ech a été ajouté. Un dernier champ bord a par ailleurs été ajouté pour éloigner la figure du bord de la fenêtre graphique. Dans l'amorce de définition de la classe GrilleObjetGraphique donnée ci-après, les valeurs de ces quatre nouveaux champs ont été définis «en dur» : on imagine que leur initialisation pourrait être réalisée par un constructeur.
class GrilleObjetGraphique{
private GrilleObjet grille; // la grille encapsulée
private int cote = 7; // côté (# pixels) du carré pour un point
private int rayon = 7; // rayon du cercle (# pixels) pour un voisin
private int ech = 15; // facteur d'échelle
private int bord = 5; // taille (# pixels) du bord inutilisé
..........
|
2.2. La définition de la classe inclut ensuite celle d'un constructeur qui ne fait ici rien d'autre qu'instancier l'objet de la classe GrilleObjet sous-jacente de l'objet de la classe GrilleObjetGraphique (comme nous l'avons dit, on pourrait concevoir d'y réaliser l'initialisation des champs spécifiques) :
..........
GrilleObjetGraphique(int x0, int y0, int lg, int ha) {
grille= new GrilleObjet(x0, y0, lg, ha);
..........
}
|
2.3. En ce qui concerne les méthodes invocables sur une grille de la classe GrilleObjetGraphique, il faut distinguer celles qui font qu'un tel objet est également un objet de la classe GrilleObjet de celles qui font qu'il en diffère.
2.3.1. Tout d'abord, les méthodes invocables sur les objets de la classe GrilleObjet doivent l'être sur ceux de la classe GrilleObjetGraphique. Pour cela on procède par délégation. Chacune de ces méthodes est explicitement définie dans la classe GrilleObjetGraphique et se contente d'invoquer la méthode correspondante sur l'objet de la classe GrilleObjet qui y est encapsulé. Cela donne :
..........
boolean estSurLaGrille(int x, int y) {
return grille.estSurLaGrille(x,y);
}
boolean estAuBord(int x, int y)
{
return grille.estAuBord(x, y);
}
boolean estUnCoin(int x, int y)
{
return grille.estUnCoin(x, y);
}
int nombreDeVoisins(int x, int y) {
return grille.nombreDeVoisins(x,y);
}
..........
|
2.3.2. La définition de la classe GrilleObjetGraphique offre la possibilité d'invoquer sur les objets l'instanciant de nouvelles méthodes qui enrichissent l'interface de la classe GrilleObjet.
- La première chose que l'on souhaite pouvoir faire, c'est évidemment visualiser graphiquement une grille. Cela est réalisée par la méthode dessinerGrille :
..........
void dessinerGrille(){
Deug.startDrawings(ech*(grille.x0 + grille.longueur + bord),
ech*(grille.y0 + grille.hauteur + bord));
Deug.setGray(0); // dessin en noir
for(int x = ech * grille.x0;
x < ech * (grille.x0 + grille.longueur); x += ech)
for(int y = ech * grille.y0;
y < ech *(grille.y0 + grille.hauteur); y += ech)
Deug.drawRect(x, y, ech, ech);
}
..........
|
- La méthode suivante, visualiserPoint visualise un point (dont les coordonnées sont données en paramètres), s'il est sur la grille, sous la forme d'un carré plein (la couleur est un nombre entier compris entre 0 et 255 correspondant à un niveau de gris, 0 correspondant au noir et 255 au blanc et est transmis en troisième paramètre) :
..........
void visualiserPoint(int x, int y, int couleur){
if(!estSurLaGrille(x,y)) return;
Deug.setGray(couleur);
Deug.fillRect(ech*x-cote/2, ech*y-cote/2, cote, cote);
}
..........
|
- Enfin, la dernière méthode, montrerVoisins permet la visualisation des voisins d'un point de la grille. Le calcul des coordonnées des voisins d'un point est résumé dans la figure suivante :
Le code de la fonction correspondante est le suivant :
..........
void montrerVoisins(int x, int y, int coul) {
int a, b;
Deug.setGray(coul);
switch(nombreDeVoisins(x,y)) {
case 0 : return;
case 3 : a = (x == grille.x0) ? 1 : -1;
b = (y == grille.y0) ? 1 : -1;
Deug.fillCircle(ech*(x+a), ech*y, rayon);
Deug.fillCircle(ech*(x+a), ech*(y+b), rayon);
Deug.fillCircle(ech*x, ech*(y+b), rayon);
return;
case 5 : if (x == grille.x0 || x == grille.x0 + grille.longueur) {
Deug.fillCircle(ech*x, ech*(y+1), rayon);
Deug.fillCircle(ech*x, ech*(y-1), rayon);
a = (x == grille.x0) ? 1 : -1;
Deug.fillCircle(ech*(x+a), ech*(y-1), rayon);
Deug.fillCircle(ech*(x+a), ech*y, rayon);
Deug.fillCircle(ech*(x+a), ech*(y+1), rayon);
return; }
if (y == grille.y0 || y == grille.y0 + grille.hauteur) {
Deug.fillCircle(ech*(x-1), ech*y, rayon);
Deug.fillCircle(ech*(x+1), ech*y, rayon);
b = (y == grille.y0) ? 1 : -1;
Deug.fillCircle(ech*x, ech*(y+b), rayon);
Deug.fillCircle(ech*(x-1), ech*(y+b), rayon);
Deug.fillCircle(ech*(x+1), ech*(y+b), rayon);
return; }
// return
case 8 : Deug.fillCircle(ech*(x-1), ech*(y-1), rayon);
Deug.fillCircle(ech*(x-1), ech*y, rayon);
Deug.fillCircle(ech*(x-1), ech*(y+1), rayon);
Deug.fillCircle(ech*(x+1), ech*(y-1), rayon);
Deug.fillCircle(ech*(x+1), ech*y, rayon);
Deug.fillCircle(ech*(x+1), ech*(y+1), rayon);
Deug.fillCircle(ech*x, ech*(y-1), rayon);
Deug.fillCircle(ech*x, ech*(y+1), rayon);
return;
}
}
..........
|
2.4. On pourra consulter le code complet de la classe GrilleObjetGraphique ainsi qu'un exemple d'application utilisant cette classe.
3. Sous-classe et héritage
3.1. Dans la solution précédente on a fait beaucoup de choses explicitement. On a, tout d'abord, fait apparaître explicitement l'existence d'un objet de la classe GrilleObjet sous-jacent à un objet de la classe GrilleObjetGraphique. Puis, afin de pouvoir utilser un objet de la classe GrilleObjetGraphique comme un objet de la classe GrilleObjet, on a défini dans la nouvelle classe les méthodes qui étaient définies dans la classe GrilleObjet. Même si l'écriture de ces fonctions est simple, le travail étant délégué à l'objet de la classe GrilleObjet sous-jacent, il peut néanmoins paraître fastidieux.
Les langages orientés objets, et Java en particulier, permettent de réaliser de manière implicite ce type de définition de classes au travers du concept de sous-classe et du mécanisme d'héritage qui lui est attaché. Cette facilité, si elle simplifie la définition de nouvelles classes, ne manque cependant pas de soulever de délicates questions, auxquelles tous les langages ne répondent pas de la même manière. Nous n'aborderons pas dans cette première approche ces problèmes et nous contenterons, sur notre exemple d'en voir les avantages.
3.2. Le concept de sous-classe
3.2.1. L'objectif visé est simple : il s'agit de rendre implicite le fait qu'une classe est raffinement d'une autre (certains langages permettent celui de plusieurs autres, mais pas Java). En d'autres termes, un objet instanciant une classe définie comme sous-classe SC d'une autre classe C pourra être vu, de manière implicite comme intanciant la classe C. Cela signifie que la définition de la classe SC ne nécessite pas l'encapsulation explicite d'une référence sur l'objet de la classe C, ni la définition (par délégation) des méthodes invocables sur les objets de cette même classe.
Nous allons illustrer ce mécanisme par la définition d'une classe GrilleObjetGraphiqueHeritage, sous-classe de la classe GrilleObjet (on dit aussi classe dérivée).
3.2.2. D'un point de vue syntaxique, cela est particulièrement simple. En Java, on exprime le fait que GrilleObjetGraphiqueHeritage est une sous-classse de la classe GrilleObjet de la manière suivante dans sa définition :
class GrilleObjetGraphiqueHeritage extends GrilleObjet {
..........
|
3.2.3. La définition de la sous-classe contient la spécification des champs propres à la nouvelle classe, c'est-à-dire sur notre exemple :
private int rayon = 7; private int cote = 7; private int ech = 15; private int bord = 5; |
3.2.4. Un point particulier à remarquer sur la définition du constructeur donné ci-après concerne l'utilisation de la méthode notée symboliquement super. Elle correspond à un appel de constructeur de la classe dont la classe courante dérive : sur notre exemple elle permet d'instancier l'objet de la classe GrilleObjet sous-jacent à l'objet de la classe GrilleObjetGraphiqueHeritage au moyen du constructeur de signature GrilleObjet(int, int, int, int).
GrilleObjetGraphiqueHeritage(int x0, int y0, int lg, int ha) {
super(x0, y0, lg, ha);
}
|
3.2.5. Finalement, les seules méthodes qui sont à définir (sur notre exemple tout du moins) sont les méthodes non définies dans la classe GrilleObjet et qu'on souhaite ajouter à l'interface de la classe GrilleObjetGraphiqueHeritage (c'est une hautre histoire, mais disons que rein n'interdit de redéfinir dans la classe GrilleObjetGraphiqueHeritage certaines des méthodes définies dans la classe mère GrilleObjet pour en adapter le comportement aux caractéristiques de la nouvelle classe). La définition de ces fonctions est exactement la même que celle donnée pour la classe GrilleObjetGraphique
3.3. On pourra consulter le code complet de la classe GrilleObjetGraphiqueHeritage ainsi qu'un exemple d'application utilisant cette classe.