classe Object

IFT 1170, été 2009
Chapitre 8 : Héritage simple et polymorphisme
112
Héritage et polymorphisme
Observez les schémas de quelques classes vues. Ils
sont utiles pour comprendre les notions d’héritage
et de polymorphisme.
classe Object
public String toString();
public boolean equals(Object autre);
. . . etc . . .
classe Vector<E> (dérivée de Object)
public String toString();
. . . etc . . .
Number
classe Stack<E>
(Pile, dérivée de Vector)
public Stack();
public E peek();
public E pop();
public E push(E obj);
public boolean empty();
pas de toString() ni de equals()
etc . . .
classe Integer
(déjà vue)
public Integer(int n);
public String toString();
public boolean equals(Object obj);
. . . etc . . .
classe StringTokenizer
public StringTokennizer(String ch);
pas de toString() ni de equals
. . . etc . . .
Object est la super-classe de toutes les classes.

IFT 1170, été 2009
Chapitre 8 : Héritage simple et polymorphisme
113
La programmation orientée objet est basée sur trois nouveaux concepts :
- Encapsulation (déjà vu et travaillé dans les travaux pratiques)
- Héritage ( tel père => tel fils et plus!!! )
- Polymorphisme (capacité de se présenter sous plusieurs formes différentes : la
lampe magique d’Aladin???)
Héritage
La POO favorise la réutilisation des classes, des méthodes, du codage. Grâce à l'héritage,
on peut modifier une classe sans avoir à la réécrire complètement :
Pour gérer une pile selon le principe LIFO (Last In First Out : dernière entrée, première
sortie), on n'a pas besoin de casser la tête : la plupart des méthodes existantes dans Vector
nous permettent de traiter une pile.
Stack est une classe où on profite des méthodes existantes de la classe Vector.
Dans les documents de Java, on trouve la description suivante de cette classe :
public class java.util.Stack<E>
extends java.util.Vector<E> {
// constructeur :
public Stack(); // construire une pile VIDE
// méthodes :
public boolean empty() ; // la pile est-elle vide ?
// consulter l'objet au sommet sans le retirer de la pile
public E peek();
// retirer l'objet au sommet et le retourne
public E pop();
// empiler un objet au sommet de la pile
public E push ( E item) ;
// retourne la distance d'un objet vs le sommet
public int search(Object obj);
}
Le mot extends signale que Stack étend (dérive de) Vector . C'est une sous-classe de
Vector.

IFT 1170, été 2009
Chapitre 8 : Héritage simple et polymorphisme
114
Terminologie :
Vector est une super-classe de Stack
Vector est une classe de base
Vector est une surclasse
Vector est une classe parente
etc ….
Stack est une sous-classe de Vector
Stack est une classe dérivée de Vector
Stack est une classe étendue de Vector
Stack est une classe enfante de Vector
etc …
Comment écrire la méthode push (empiler) de la sous-classe Stack ?
public Object push( Object item) {
// ajouter l'item à la pile (dans le vecteur!!!)
addElement (item );
// retourner l'item (selon la syntaxe de cette méthode )
return item;
}
Conclusion : on profite (réutilise) la méthode addElement de la classe Vector.
Une version plus logique :
public void push( E item) {
// ajouter l'item à la pile (dans le vecteur!!!)
addElement (E );
}
Comment afficher le contenu d'une pile ???
Notez que la méthode toString() n'existe pas dans Stack. Cependant elle existe dans la
classe Vector. L'affichage le contenu d'une pile n'est pas une action importante de la
gestion d'une pile. Au lieu de perdre le temps de développer une telle méthode, pourquoi
ne pas utiliser celle qui existe dans la super classe Vector?
Supposons qu'une pile contient 7 journées d'une semaine dont on a empilé
successivement les journées "Lundi", "Mardi", …, "Dimanche".
La méthode suivante permet d'afficher le contenu de la pile :

IFT 1170, été 2009
Chapitre 8 : Héritage simple et polymorphisme
115
static void afficher( Stack unePile, String message) {
if ( unePile.empty() )
System.out.println("La pile est vide. Sa taille est " +
unePile.size());
else {
System.out.println("Contenu de la pile " + message + " : ");
System.out.println( unePile );
}
System.out.println();
}
Comme toString() n'esiste pas dans Stack mais elle existe dans Vector.
Java utilise la méthode toString() de la classe Vector pour afficher
le contenu de la pile :
Contenu de la pile apres avoir empile les 7 journees :
[Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche]
Conclusion : on profite (réutilise) la méthode toString() de la classe Vector.
Héritage simple : une classe peut hériter d'une seule super-classe
classe Triangle avec 3 côtés (côté1, côté2, côté3)
Triangle rectangle
Triangle isocèle
Triangle équilatéral
(3 côtés égaux)
Un triangle équilatéral est un triangle isocèle.
Un triangle isocèle est aussi un triangle.
etc . . .

IFT 1170, été 2009
Chapitre 8 : Héritage simple et polymorphisme
116
Java permet d'implémenter facilement l'héritage simple.
Ce type d'héritage est fréquent dans les classes prédéfinies de Java:
La seule super classe de Stack est Vector.
La seule super classe de Vector est Object.
Notez qu’une super-classe (exemple Number dans java.lang) peut disposer
de plusieurs sous-classes : Integer, Double, Float, Long.
Héritage multiple:
une classe peut hériter de plus d'une super-classe
Ce concept est permis en C++ mais non en Java. Java utilise la notion de l'interface
(matière vers la fin de session) pour contourner ce problème.
Surdéfinir (surcharger, overloading)
La surdéfinition permet au programmeur de déclarer plusieurs méthodes ou constructeurs
ayant le même nom, mais ayant des paramètres différents ou du genre différent (avec
return, de type void).
On a déjà vu fréquemment des constructeurs sans paramètres, constructeurs avec
paramètres qui portent le même nom (de la classe) :
public Rectangle() { } // constructeur d'un rectangle
public Rectangle(int lo, int la) {. . . } // constructeur avec paramètres
La méthode afficher est aussi fréquemment surdéfinie dans les projets:
public void afficher(int nombre, int nbCol) // afficher un nombre avec tant de colonnes
public void afficher(String nom) // afficher un objet en connaissant son nom
public void afficher(Vector v, String message) // afficher le contenu d'un vecteur …
Redéfinir (overriding):
Avec l'héritage, il est utile, dépendant des besoins, de redéfinir des méthodes existantes
d'une super-classe. C'est le cas des deux méthodes toString() et equals qui sont souvent
redéfinies dans la plupart des sous-classes d'Object .
La méthode toString() est redéfinie dans String, Integer. Par cette raison, l'affichage
suivant fonctionne parfaitement :
String souhait = "Bonne chance!" ;
Vector<Integer> v = new Vector<Integer> ();
v.addElement ( new Integer (23) );
v. addElement ( new Integer (15);