Série d’exercices 2 (Héritage, Interfaces, Classes Abstraites)

Exercice 1 (héritage simple)

Les échecs fournissent un exemple classique d'application de l'héritage qui est très riche. Cet
exercice aborde seulement une partie du sujet.

1/ Créer la classe PieceEchec qui s'intéresse au déplacement d'une pièce. Elle prend comme
champs, la position des cases de départ et d'arrivée lors d'un déplacement, ainsi que le nom de
la pièce. La position d'une case est définie par deux entiers compris entre 1 et 8: le numéro de
la rangée et celui de la colonne. La classe PièceEchec possède les méthodes suivantes:

 norme( ) (norme du déplacement) retournant le carré de la distance entre les cases de

départ et d'arrivée,
 estValide( ) qui retourne 1 si la case de d'arrivée est dans l'échiquier et 0 sinon (on peut
aussi utiliser un booléen).

Cette classe comporte aussi un constructeur pour initialiser les champs et un constructeur
vide.

2/ Quand un cavalier se déplace la norme du déplacement vaut 5. Créer une classe Cavalier
étendant la classe PieceEchec, dont le constructeur fait appel à celui de la super classe. De
même la méthode estValide() de Cavalier utilisera la méthode estValide() de la super classe.

Suggestion: On peut poursuivre l'étude de cette question en ajoutant d'autres pièces. Le fou se
déplace en diagonale alors que la tour utilise la rangée et les colonnes. La reine a les capacités
d'une tour et d'un fou. La classe Reine ne peut pas hériter des classes Fou et Tour., car
l'héritage multiple est impossible. Le roi a les capacités de déplacement d'une reine mais il ne
peut se transporter que sur une case contiguë (sauf au moment du roque). On peut donc
considérer la classe Roi comme une sous-classe de Reine, ou se contenter de considérer qu'un
roi est une pièce dont la norme du déplacement vaut 1 ou 2.

Exercice 2 (classe abstraite)

1/ Ecrire une classe abstraite nommée FonctionNommee qui permet de définir le nom d'une
fonction (possède un champ String), une méthode abstraite appelée calculer (public abstract
double calculer (double x)) qui va être redéfinie dans les classes filles (cette méthode permet
de définir ce que fait la fonction Exp: une classe qui permet de calculer cos(x) – x). Elle
comporte en plus une méthode imprimer (public void imprimer(double x) ) qui permet
d'afficher le nom de la fonction, son paramètre et le résultat (Exp: pour cos(2) – 2  on aura
comme affichage 2 + Nom de la Fonction + Résultat).

2/ Etendre la classe FonctionNommee par la classe nommée CosMoinsNommee correspondant

à la fonction cos(x) – x. Cette classe redéfinira donc la méthode calculer, elle contiendra en
plus un constructeur dans lequel on définit un nom de fonction.

2/ Ecrire une classe nommée ImprimerFonction qui est destinée à lister les valeurs d'une
fonction depuis une borne inférieur jusqu'à une borne supérieure avec un pas donné. La classe
comportera donc un champ FonctionNommee qui est la fonction à étudier, un champ
définissant la borne inférieur, un champ définissant la borne supérieure et un champ
définissant le pas. Elle contiendra en plus un constructeur, une méthode appelée lister( ) qui
permet d'imprimer les valeurs qu'on veut et la fonction main ( ) dans laquelle on fera une
application avec un objet CosMoinsNommee.

Exercice 3 (Classe abstraite, Liste chaînée)

On veut modéliser la gestion d'une bibliothèque : on définira un certain nombre de classes :

Main, Ouvrage, BiblioTab, Bibliotheque, Periodique, CD, Livre. Les livres auront comme
propriétés : auteur, titre, éditeur ; les périodiques : nom, numéro, périodicité ; les CDs : titre,
auteur. De plus tous les ouvrages auront une date d'emprunt (potentiellement nulle), une cote
(le numéro par ordre de création). On implémentera également sur chaque objet une méthode
toString() renvoyant toutes les informations sur l'ouvrage sous forme d'une chaîne de
caractères.

La classe BiblioTab permettra de stocker dans une structure les livres (ajout et suppression, la
suppression prenant en argument la cote de l'ouvrage). Elle aura également une méthode
toString() affichant le nombres d'ouvrages, puis chaque ouvrage successivement. La classe
Bibliotheque sera simplement une version abstraite déclarant les mêmes méthodes que
BiblioTab mais sans les implémenter. BiblioTab héritera de Bibliotheque.

La classe Main ne contiendra que la méthode main et testera la bibliothèque en y insérant et

supprimant quelques ouvrages, puis en affichant le contenu de la bibliothèque.

1.Représentez les différentes classes dans un graphe d'héritage. On mettra en évidence pour
chaque classe les méthodes et les champs qu'elle définit, redéfinit ou hérite. On souhaite que
tous les champs soient déclarés privés et que l'on puisse y accéder de l'extérieur que par des
méthodes.
2.Implémentez les classes ci-dessus. Pour la classe BiblioTab on utilisera un tableau de
longueur suffisante (on vérifiera quand même à chaque opération d'insertion que l'on ne
dépasse pas les bornes du tableau). Quel sont les inconvénients de cette méthode ?

Dans ce qui suit, on veut implémenter une deuxième version de la bibliothèque, que l'on
appellera BiblioList et qui héritera également de Bibliotheque. Cette nouvelle implémentation
utilisera la classe LinkedList définie dans l'API Java standard.

1.Modifiez le minimum de choses dans la classe Main pour permettre l'utilisation de

BiblioList.
2.En utilisant les méthodes boolean add(Object o) qui permet d'ajouter un objet dans la liste,
boolean remove(Object o) Object get(int index) et int size(), implémentez la classe BiblioList.