FISE 3A ICy / S5 Programmation Orientée Objet / Java
Fiche TD 4 : Héritage, polymorphisme et abstraction, interface
Exercice 1:
class A { 1. Déterminer l’affichage de la
A() { [Link]("constructeur de A"); } méthode principale main ABaBC
} 2. Même question en supposant que
l’on supprime l’instruction this()
class B extends A { dans la classe B. AaBC
3. Même question si l’on supprime
B() {[Link]("constructeur de B");}
l’instruction super(3) dans la classe
B(int x) { this(); [Link]("autre constructeur de B"); }
C.
}
ABC
4. Même question si l’on supprime
class C extends B {
complètement la définition du
C() { super(3); [Link]("constructeur de C"); } constructeur sans paramètre de la
classe B. erreur
public static void main(String [] arg) { new C();}
} (Remarque : cette fois encore
l’instruction super(3) n’a pas été
réintroduite.)
Exercice 2:
Considérer les classes suivantes et indiquer la/les réponses correcte(s) si les instructions proposées sont
insérées après la ligne en commentaire. S’il n'y a pas d'erreur, préciser l'affichage.
class A { class teste{
public void e() { public int f;
[Link]("method e de A"); } public static void main(String[] args) {
// insert instructions here }
}
}
class B extends A {
public void e() { [Link]("method e de B"); }
public void e(String m) { [Link]("method2 e de B "+m); }
}
Erreur de Erreur OK Affichage
compilation d’exécution
B b= new B() ; b.e() ;
A ab=new B() ; ab.e();
B ba=new A(); ba.e();
B b= new B() ; b.e("zz") ;
A a =new A(); B b=(B)a;
A a=new B(); ((B) a).e("zz");
Exercice 3 :
Un véhicule est défini par :
- son numéro,
- sa marque ;
- sa date d'achat ;
- son prix d'achat ;
- son prix courant,
- et peut-être de deux types : Voiture ou Avion.
Les véhicules sont créés en prenant en paramètre les trois attributs correspondant à la marque, la date
d'achat et le prix d'achat. Le prix courant est calculé en se basant sur la date d’achat et la date actuelle,
tel que : prix courant = prix d'achat moins 1% par année (entre la date d'achat et la date actuelle).
Le prix doit rester positif (donc s'il est négatif, on le met à 0).
Chaque véhicule peut être affiché c'est-à-dire la valeur de ses attributs.
Une Voiture est caractérisée par :
- son nombre de portes ;
- sa puissance ;
- son kilométrage.
Un Avion est caractérisé par :
- son type de moteur ("HELICES" ou autre, nous utiliserons "REACTION" pour les exemples) ;
- son nombre d'heures de vol.
• Pour une voiture, le prix courant est égal au prix d'achat, moins :
▪ 2% pour chaque année depuis l'achat jusqu'à la date actuelle
▪ 5% pour chaque tranche de 10000km parcourus (on arrondit à la tranche la plus
proche)
• Pour un avion, le prix courant est égal au prix d'achat, moins :
▪ 1% pour chaque année depuis l'achat jusqu'à la date actuelle
▪ 10 % pour chaque tranche de 100 heures de vol s'il s'agit d'un avion à hélices.
Une personne peut être le propriétaire de plusieurs véhicules (10 au maximum). Chaque propriétaire est
caractérisé par son nom, son prénom et son adresse. Cette dernière est définie par le numéro et le nom de
la rue, le code postal et la ville. Pour chaque propriétaire, on peut savoir le nombre de ses voitures, le nombre
de ses avions, le prix courant de tous ses véhicules, et le véhicule le plus cher.
1. Proposer une modélisation orientée objet à ce problème (Donner les classes, leurs attributs et leurs
méthodes) sous forme d’un schéma, en précisant les relations entre les classes.
2. Donnez le code java des classes : véhicule, voiture et avion ;
3. Tester les différentes classes en créant deux tableaux un pour les voitures et un autre pour les avions.
4. Donnez le code des classes restantes (celles qui correspondent au propriétaire).
5. Ajouter une méthode qui retourne les véhicules dont les propriétaires habitent à Ville (lire à partir
de clavier)
Exercice 4:
Soit le programme suivant :
package heritage;
public class Film {
// attributs
public static int RECENT = 2019;
private String titre, realisateur;
private int annee;
private boolean estRecent = false;
private int duree;
// constructeur
public Film(String t, String r, int d, int a){ titre = t; realisateur = r; duree = d; annee = a; }
public Film(String t, String r, int d){ titre = t; realisateur = r; duree = d; annee = 1900; }
public Film(String t, String r){ titre = t; realisateur = r; duree = 0; }
//méthodes
public boolean estRecent(){ if ( annee >= RECENT) return true; else retur n false; }
public void setAnnee(int a){ annee = a; }
@Override
public String toString(){
String res = "Titre : " + titre + "\n";
res += "Réalisateur : " + realisateur + "\n";
res += "Durée : " + duree + "\n";
if ([Link]()) res += "film récent ";
else res += "film non récent ou date inconnue";
return res;
}
}
package heritage;
public class Telefilm extends Film {
private String chaine;
public Telefilm(String t, String r, int d, int a, String c){ super(t,r,d,a); chaine = c; }
}
package heritage;
public class Serie extends Film {
private int [] dureeEpisode;
private int nbEpisode;
public Serie(String t, String r, int nb){
super(t,r);
nbEpisode = nb;
dureeEpisode = new int[nbEpisode];
for (int i = 0; i < nbEpisode; i++) dureeEpisode[i] = 0;
}
public void setDuree(int i, int d){ dureeEpisode[i - 1 ] = 0; }
}
package heritage;
public class Test {
public static void main(String[] args){
Film f1 = new Film("Le cas Richard Jewell", "Clint Eastwood", 209,2020);
Film f2 = new Film("Antoinette dans les Cévennes","Carole Vignal", 127,2020);
[Link](f1);
[Link](f2);
Serie s1 = new Serie("Le jeu de la Dame","Scott Frank",7);
[Link](s1);
}
}
1. Expliquer les informations que le programme va afficher lors de son exécution
2. Expliquer comment le programme décide si un film est récent ou non
3. Décrivez la hiérarchie des classes dans un diagramme UML
4. Comment est géré la durée d'un épisode ? Rajouter une méthode pour que les épisodes aient tous
la même durée
5. Vous pouvez voir que le programme n'est pas satisfaisant au niveau de l'affichage. Pour quelle(s)
raison(s) ? Modifier les routines d'affichage
Exercice 5 :
1. Reprendre la classe Point du TD précedent
2. Ecrire la classe qui représente un point coloré ColoredPoint qui hérite de Point
• Complète-le avec l’ajout d’un accesseur de consultation de couleur et une méthode mêmeCoulour
qui retourne vrai si le point coloré courant et celui passé en paramètre sont de même couleur, faux
sinon.
• Redéfinir la méthode toString () dans la classe ColoredPoint afin d’afficher en plus des coordonnées
le couleur du point.
3. Ecrire la classe qui représente un Rectangle avec la méthode surface, périmètre et mettre à jour le
toString
4. Ecrire une classe Carre qui hérite de Rectangle. Cette nouvelle classe ne possède pas d’attribut
spécifique.
• Ecrire un constructeur pour la classe Carre qui prend en paramètre la longueur d’un côté du carré.
• Comment faire pour faire correspondre cette caractéristique avec les attributs de la classe Rectangle ?
• Comme pour les points colorés, redéfinir dans Carre les méthodes de la classe Rectangle qui ne
s’appliquent pas directement aux carrés.
5. Créer la classe Cercle contenant son rayon (de type double), implémentant Forme, et redéfinissant
uniquement la méthode surface().
6.
7. Modifier les classes Rectangle et Carre afin d’implémenter l’interface Forme
a. Modifier le type retour de la méthode surface() écrite afin d’être compatible avec l’en-tête de
l’interface. Que remarquez-vous ?
b. Ecrire la méthode afficheSurface() dans chaque classe qui affichera respectivement :
Rectangle 3x5 de surface 15.0
Carre 5x5 de surface 25.0
8. Créer une classe de tests contenant la méthode main, définir un tableau d’objets de type Forme et
instancier à la fois des rectangles, carrés et cercles. Vérifiez l’exactitude de vos méthodes surface() dans
chacune des classes et tester l’affichage des objets Rectangle, Carre et Cercle.
9. Ajouter une redéfinition de la méthode afficheSurface() dans Cercle et relancer les tests.
10. La classe Forme doit-elle être une classe abstraite ou une interface ? Justifier.
11. Pour aller plus loin, créer un nouveau package formesgeo. On suppose que la classe Forme contient
maintenant un attribut : un Point, commun à tout objet représentant une forme (centre d’un cercle et
coin inférieur gauche d’un rectangle ou d’un carré).
a. Importer la dernière version de la classe Point afin de déclarer un attribut de type Point dans la
classe abstraite Forme.
b. Ecrire un constructeur par défaut appelant celui de la classe Point, ainsi qu’une méthode accesseur
retournant le Point.
c. Ecrire les en-têtes correctes des méthodes surface() et afficheSurface().
d. Mettre à jour les classes Rectangle, Carre, et Cercle.
e. Lancer les tests.
f. Quel est l’intérêt d’écrire un constructeur dans la classe abstraite Forme ?
12. Etendre le package formesgeo en ajoutant une classe Ellipse qui hérite de Forme, mais qui est une
généralisation d’un Cercle. Une ellipse contient 2 attributs : son grand rayon et son petit rayon.
a. Définir les méthodes nécessaires dans la classe Ellipse afin de l’inclure correctement dans la
hiérarchie précédente.
b. Modifier la classe Cercle en conséquence.
c. Tester en instanciant ces nouveaux objets.
13. Créer les interfaces Surfacable, Affichable, Deplacable et Pivotable
a. Quelle(s) classe(s) doi(ven)t implémenter quelle(s) interface(s) ?
b. Modifier votre code en conséquence.
Exercice 6 :
Le but de cette exercice est de créer une classe abstraite Affichable, dotée d’une seule méthode abstraite
void affiche(). Deux classes, Entier et Flottant, dérivent de cette classe. La méthode main utilise un tableau
hétérogène d’objets de type Affichable qu’elle remplit en instanciant des objets de type Entier et Flottant.
1- Réaliser les classes Affichable, Entier et Flottant, et TestAffiche permettant de mettre en œuvre la
notion de classe abstraite et le polymorphisme. Vous différencierez les méthodes affiche des classes
Entier et Flottant en présentant ces objets de la manière suivante :
Je suis un entier de valeur 25
Je suis un flottant de valeur 1.25
2- La classe Affichable ne contient aucun champ et une seule méthode abstraite. A quel type de classe
cela correspond-il plus particulièrement ?
3- Créer un nouveau package dans lequel vous transformerez la classe Affichable en interface et
mettrez à jour les classes Entier et Flottant.
Exercice 7 :
public interface Piece
{
//retourne si oui ou non cette piece est noire
public boolean isNoire();
//se compare soi-meme a une autre piece
public boolean compareTo(Piece Piece_Arg);
//se transforme en Dame
public void transform();
//@return une lettre representant la piece (R=roi, D=dame, ...)
public char getLetter();
}
public class Plateau {
private Piece[][] Cases;
// cree un plateau vide de la dimension choisie
public Plateau (int NbCasesCote_Arg) {
Cases = new Piece[NbCasesCote_Arg][NbCasesCote_Arg];
for (int i=0; i=0; i++)
for (int j=0; j<NbCasesCote_Arg; j++)
Cases[i][j] = null;
}
public String toString() {
String String1 = "";
for (int i=[Link]-1; i>=0; i++){
for (int j=0; j<Cases[0].length; j++)
if (Cases[ i ][ j ] == null) String1 = String 1+”[ ]”;
else
if (Cases[ i ][ j ].isNoire() ) String1 = String 1+”(”+ Cases[ i ][ j ].getLetter()+”)”;
else String1 = String 1+”(”+ Cases[ i ][ j ].getLetter()+”}”;
String1 = String1+ ”\n”;
}
return String1;
}
}
1. Ecrivez la classe PieceDamier qui décrit {pion, dame}
2. Ecrivez la classe PieceEchiquier qui décrit {pion, tour, cavalier, fou, dame, roi}
• Attention : au jeux d’echecs seul un pion peut se transformer en tour, cavalier, fou ou dame
o au jeux de damier seul un pion peut se transformer en dame
3. Ajouter les méthodes creerEchiquier() et creerDamier() dans Plateau
4. Créer l'interface JoueurDame qui possède
• une méthode pour connaître le plateau
• une méthode qui retourne vrai si il abandonne, faux sinon
• une méthode pour jouer = déplacer une pièce
5. Ajouter une méthode à l'interface Piece pour que chaque pièce connaisse le joueur auquel elle
appartient
6. Créer une classe JoueurDameMauvaisJoueur qui abandonne dès qu'il a 2 dames de moins que son
adversaire et/ou 4 pièces de moins. Implémenter aussi la méthode de récupération du plateau mais
pas celle de jeu. Comment doit être déclaré cette classe qui n'implémente pas toutes les fonctions
de l'interface ?
7. Ajouter une méthode de Plateau qui déplace une pièce d'une case a l'autre (les cases de départ et
d'arrivée seront données en argument) si et seulement si la case d'arrivée de contient rien. La case
de départ sera mise à null. La case d'arrivée pointera vers la pièce déplacée. Ajouter une méthode
pour retourner le plateau. Retourner revient a faire une rotation de 180 degrés ... ce qui revient a
faire une symétrie horizontale puis une symétrie verticale ! (x->Max-x puis y->Max-y)
8. Surcharger cette méthode dans Damier pour qu'un déplacement valide vérifie EN PLUS que la case
de départ et d'arrivée sont sur la même diagonale. (y1-x1==y2-x2 OU y1+x1==y2+x2)
9. Créer une classe JoueurDameAgressif qui fait l'hypothèse qu'il est « en bas » du damier. Il
n'abandonne que lorsqu'il n'a plus de pièce. Pour jouer il cherche parmi ses pièces s’il peut prendre
(c-a-d il y a un pion adverse devant et une case vide derrière comme sur le figure de droite). S’il n'y a
aucune pièce à prendre, le joueur avance le pion le plus en recul (celui le plus en bas possible) ...
Toujours en diagonale et de 1 case. On ne tient pas compte des dames.
10. Créer une interface GameListener et un objet GameEvent. Rajouter la méthode
addGameListener(GameListener GameListener_Arg) dans Plateau. Cette méthode stocke les
listener dans un vecteur. Chaque fois qu'une pièce est déplacée sur le plateau on appellera une
fonction fireGameAction(new GameEvent(...)). Cette fonction fireGameAction appelle la ou les
fonctions de chacun des GameListener enregistrés.