geneli~1.book Page 78 Lundi, 10.

juillet 2006 12:46 12

L’héritage et le polymorphisme Chapitre 5

60 Définition d’une classe dérivée,

droits d’accès (1)
On dispose de la classe suivante :
class Point
{ public void initialise (int x, int y) { this.x = x ; this.y = y ; }
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public int getX() { return x ; }
public int getY() { return y ; }
private int x, y ;
}
Réaliser une classe PointA, dérivée de Point disposant d’une méthode affiche affichant (en
fenêtre console) les coordonnées d’un point. Ecrire un petit programme utilisant les deux
classes Point et PointA.
Que se passerait-il si la classe Point ne disposait pas des méthodes getX et getY ?

Il suffit de définir une classe dérivée en utilisant le mot clé extends. La méthode affiche,
comme toute méthode d’une classe dérivée a accès à tous les membres publics de la classe de
base, donc en particulier à getX et getY.
class PointA extends Point
{ void affiche()
{ System.out.println ("Coordonnees : " + getX() + " " + getY()) ;
}
}
On peut alors créer des objets de type PointA et leur appliquer aussi bien les méthodes publi-
ques de PointA que celles de Point comme dans ce programme accompagné d’un exemple
d’exécution :
public class TsPointA
{ public static void main (String args[])
{ Point p = new Point () ;
p.initialise (2, 5) ;
System.out.println ("Coordonnees : " + p.getX() + " " + p.getY() ) ;
PointA pa = new PointA () ;
pa.initialise (1, 8) ; // on utilise la methode initialise de Point
pa.affiche() ; // et la methode affiche de PointA
}
}

Coordonnees : 2 5
Coordonnees : 2 5

78 © Éditions Eyrolles
geneli~1.book Page 79 Lundi, 10. juillet 2006 12:46 12

Exercice 61 Définition d’une classe dérivée, droits d’accès (2)

Notez bien qu’un appel tel que p.affiche() conduirait à une erreur de compilation puisque la
classe de p (Point) ne possède pas de méthode affiche.
Si la classe Point n’avait pas disposé des méthodes d’accès getX et getY, il n’aurait pas été
possible d’accéder à ses champs privés x et y depuis la classe PointA. Il n’aurait donc pas été
possible de la doter de la méthode affiche. L’héritage ne permet pas de contourner le principe
d’encapsulation.

Comme nos classes ne disposent pas de constructeur, il est possible de créer des objets sans les
initialiser. Dans ce cas, leurs champs auront simplement une valeur "nulle", c’est-à-dire ici la
valeur entière 0.

61 Définition d’une classe dérivée,

droits d’accès (2)
On dispose de la classe suivante :
class Point
{ public void setPoint (int x, int y) { this.x = x ; this.y = y ; }
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public void affCoord ()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points définis
par deux coordonnées (int) et un nom (caractère). On y prévoira les méthodes suivantes :
• setPointNom pour définir les coordonnées et le nom d’un objet de type PointNom,
• setNom pour définir seulement le nom d’un tel objet,
• affCoordNom pour afficher les coordonnées et le nom d’un objet de type PointNom.
Écrire un petit programme utilisant la classe PointNom.

Nous définissons une classe dérivée en utilisant le mot clé extends :

class PointNom extends Point
Dans cette classe PointNom, nous introduisons un champ (de préférence privé) destiné à
contenir le nom du point :
private char nom ;

© Éditions Eyrolles 79
geneli~1.book Page 80 Lundi, 10. juillet 2006 12:46 12

L’héritage et le polymorphisme Chapitre 5

La méthode setNom est triviale. Compte tenu de l’encapsulation des données de Point, nos
deux autres méthodes doivent absolument recourir aux méthodes publiques de Point.
En définitive, voici la définition de notre classe PoitnNom :
class PointNom extends Point
{ public void setPointNom (int x, int y, char nom)
{ setPoint (x, y) ;
this.nom = nom ;
}
public void setNom(char nom)
{ this.nom = nom ;
}
public void affCoordNom()
{ System.out.print ("Point de nom " + nom + " ") ;
affCoord() ;
}
private char nom ;
}

Voici un programme d’utilisation de PointNom :

public class TsPointN
{ public static void main (String args[])
{ Point p = new Point () ;
p.setPoint (2, 5) ;
p.affCoord() ;
PointNom pn1 = new PointNom() ;
pn1.setPointNom (1, 7, 'A') ; // methode de PointNom
pn1.affCoordNom() ; // methode de PointNom
pn1.deplace (9, 3) ; // methode de Point
pn1.affCoordNom() ; // methode de PointNom

PointNom pn2 = new PointNom() ;

pn2.setPoint (4, 3) ; // methode de Point
pn2.setNom ('B') ; // methode de PointNom
pn2.affCoordNom() ; // methode de PointNom
pn2.affCoord() ; // methode de Point
}
}

Coordonnees : 2 5
Point de nom A Coordonnees : 1 7
Point de nom A Coordonnees : 10 10
Point de nom B Coordonnees : 4 3
Coordonnees : 4 3

80 © Éditions Eyrolles
geneli~1.book Page 81 Lundi, 10. juillet 2006 12:46 12

Exercice 62 Héritage et appels de constructeurs

1. Ici encore, comme nos classes ne disposent pas de constructeur, il est possible de créer des
objets sans les initialiser. Dans ce cas, leurs champs auront simplement une valeur "nulle",
c’est-à-dire ici la valeur entière 0 pour les coordonées et le caractère de code nul pour le
nom.
2. Comme la classe Point ne dispose pas de méthodes d’accès aux coordonnées, on voit
que la méthode affCoordNom n’a pas d’autre possibilité que de recourir à la méthode
affCoord de Point, ce qui impose des contraintes sur la présentation des résultats. En
particulier, il serait impossible d’afficher sur une même ligne le nom du point avant les
coordonnées.

62 Héritage et appels de constructeurs

On dispose de la classe suivante (disposant cette fois d’un constructeur) :
class Point
{ public Point (int x, int y) { this.x = x ; this.y = y ; }
public void affCoord()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points définis
par leurs coordonnées (entières) et un nom (caractère). On y prévoira les méthodes
suivantes :
• constructeur pour définir les coordonnées et le nom d’un objet de type PointNom,
• affCoordNom pour afficher les coordonnées et le nom d’un objet de type PointNom.
Écrire un petit programme utilisant la classe PointNom.

Cet exercice est voisin de l’exercice 61 mais, cette fois, les deux classes disposent d’un cons-
tructeur. Celui de la classe dérivée PointNom doit prendre en charge la construction de l’inté-
gralité de l’objet correspondant, quitte à s’appuyer pour cela sur le constructeur de la classe de
base (ce qui est indispensable ici puisque la classe Point ne dispose pas de méthodes d’accès).
Rappelons que l’appel du constructeur de la classe de base (fait à l’aide du mot clé super) doit
constituer la première instruction du constructeur de la classe dérivée.

© Éditions Eyrolles 81
geneli~1.book Page 82 Lundi, 10. juillet 2006 12:46 12

L’héritage et le polymorphisme Chapitre 5

En définitive, voici ce que pourrait être la définition de notre classe PointNom :

class PointNom extends Point
{ public PointNom (int x, int y, char nom)
{ super (x, y) ;
this.nom = nom ;
}
public void affCoordNom()
{ System.out.print ("Point de nom " + nom + " ") ;
affCoord() ;
}
private char nom ;
}

Voici un petit programme d’utilisation de PointNom :

public class TsPointC
{ public static void main (String args[])
{ PointNom pn1 = new PointNom(1, 7, 'A') ;
pn1.affCoordNom() ; // methode de PointNom
PointNom pn2 = new PointNom(4, 3, 'B') ;
pn2.affCoordNom() ; // methode de PointNom
pn2.affCoord() ; // methode de Point
}
}

Point de nom A Coordonnees : 1 7

Point de nom B Coordonnees : 4 3
Coordonnees : 4 3

63 Redéfinition
On dispose de la classe suivante :
class Point
{ public Point (int x, int y) { this.x = x ; this.y = y ; }
public void affiche()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points définis
par leurs coordonnées et un nom (caractère). On y prévoira les méthodes suivantes :
• constructeur pour définir les coordonnées et le nom d’un objet de type PointNom,
• affiche pour afficher les coordonnées et le nom d’un objet de type PointNom.

82 © Éditions Eyrolles
geneli~1.book Page 83 Lundi, 10. juillet 2006 12:46 12

Exercice 63 Redéfinition

Cet exercice est voisin de l’exercice 62. L’écriture du constructeur reste la même. Mais, cette
fois, on doit redéfinir la méthode affiche dans la classe dérivée. L’affichage du nom n’y pose
aucun problème :
System.out.print ("Point de nom " + nom + " ") ;
En revanche, il nous faut faire appel à la méthode affiche de la classe de base. Pour ce faire,
nous employons le mot clé super :
super.affiche() ;
En définitive, voici la définition de notre classe, accompagnée d’un petit programme
d’utilisation :
class PointNom extends Point
{ public PointNom (int x, int y, char Nom)
{ super (x, y) ;
this.Nom = Nom ;
}
public void affiche()
{ System.out.print ("Point de nom " + Nom + " ") ;
super.affiche() ;
}
private char Nom ;
}
public class TsPointR
{ public static void main (String args[])
{ Point p = new Point (3, 7) ;
p.affiche() ; // methode de Point
PointNom pn = new PointNom(1, 7, 'A') ;
pn.affiche() ; // methode de PointNom
}
}

Coordonnees : 3 7
Point de nom A Coordonnees : 1 7

Ici, la redéfinition de la méthode affiche dans PointNom utilise la méthode affiche de la classe
ascendante Point, ce qui impose de recourir au mot clé super. Bien entendu, il n’en ira pas
toujours ainsi : rien n’empêche de redéfinir entièrement une méthode sans chercher à exploiter
celle de la classe ascendante.

© Éditions Eyrolles 83