Download Programmation java orienté objet and more Exercises Java Programming in PDF only on Docsity!
Plan
Problématiques abordées :
I conception POO, héritage, classes abstraites (prix, affichage)
I affichage polymorphique
I interfaces
I copie polymorphique
Le problème
I Les montres sont des produits (que l’on peut vendre : ont un prix)
I Les montres ont un mécanisme de base et sont constituées de différents
accessoires (boîtier, bracelet, ...)
I Les produits ont un prix dont le calcul peut varier, à partir d’une valeur de base
I Tous les produits sont « affichables », chacun à sa façon
I Les mécanismes et accessoires de montre sont aussi des produits (on pourrait
en acheter séparément)
I Il existe trois sortes de mécanismes : analogiques (montre à aiguilles), digitaux
et doubles.
I Pour les mécanismes doubles, on supposera ici qu’ils n’indiquent qu’une seule
heure, mais se comportent sinon à la fois comme des mécanismes
analogiques et comme des mécanismes digitaux
Hiérarchie de classes
Produit
Accessoire
Montre
Boitier
Bracelet
Fermoir
Vitre
MecanismeAnalogique
MecanismeDigital
MecanismeDouble
Mecanisme
Du problème au premier code
I Les montres sont des produits class Produit {
class Montre extends Produit { }
// ========================================== class Montres { public static void main(String args[]) {} }
Du problème au premier code
I Les montres ont un mécanisme
et sont constituées de différents
accessoires
import java.util.ArrayList; // ...
// ========================================== class Accessoire { }
// ========================================== class Mecanisme { }
// ========================================== class Montre extends Produit { private Mecanisme coeur; private ArrayList accessoires; }
Du problème au premier code
I Les produits ont un prix
class Produit { private double prix; }
// ...
Du problème au premier code
I Les produits ont un prix dont le
calcul peut varier, à partir d’une
valeur de base
class Produit { private double valeur;
public double prix() { return valeur; } }
// ...
Du problème au premier code
I Tous les produits sont « affichables »,
chacun à sa façon
class Produit { private double valeur;
public virtual double prix() { return valeur; }
public String toString() { //.. } }
// ...
Affichage polymorphique
I Tous les produits sont « affichables », chacun à sa façon
+ affichage polymorphique?
Le plus naturel est de redéfinir la méthode toString héritée de Object :
Affichage par défaut
Précisons son comportement par défaut :
@Override public String toString() { return prix(); }
Finalisation de la classe Produit
Supposons enfin que :
I un produit n’existe pas en tant que
tel : c’est une abstraction
abstract class Produit {
//... }
Finalisation de la classe Produit
Supposons enfin que :
I l’on fixe la valeur de base d’un
produit au départ et que l’on ne
puisse pas en changer
abstract class Produit {
private final double valeur;
public Produit(double uneValeur) { valeur = uneValeur; } }
Finalisation de la classe Produit
Supposons enfin que :
I un produit ait par défaut une valeur
de base nulle
La classe Produit
abstract class Produit {
private final double valeur;
public Produit(double uneValeur) { valeur = uneValeur; }
public Produit() { valeur = 0.0; }
public double prix() { return valeur; }
public String toString() { return Double.toString(prix()); }
}
Quelques accessoires
Décidons par exemple que
les accessoires :
I s’affichent en indiquant leur nom et
leur prix
abstract class Accessoire extends Produit { private final String nom;
public Accessoire(String unNom, double valeurDeBase) { super(valeurDeBase); nom = unNom; }
@Override public String toString() { String result = nom + " coûtant "; result += super.toString(); return result; } }
Quelques accessoires
Décidons par exemple que
les accessoires :
I que leur prix est celui d’un produit
usuel
Quelques accessoires
class Bracelet extends Accessoire {
public Bracelet(String unNom, double valeurDeBase) { super("bracelet " + unNom, valeurDeBase); } }
//------------------------------------------------------
class Fermoir extends Accessoire { public Fermoir(String unNom, double valeurDeBase) { super("fermoir " + unNom, valeurDeBase); } }
//...
Finalisation des Montre s
Pour finaliser la classe Montre
(mais sans mécanisme) :
I contentons nous pour l’heure
d’un constructeur par défaut
class Montre extends Produit {
private Mecanisme coeur; private ArrayList accessoires;
public Montre() { accessoires = new ArrayList(); } // ... }
Finalisation des Montre s
Pour finaliser la classe Montre
(mais sans mécanisme) :
I décidons d’un calcul de prix :
somme des prix des accessoires
@Override public double prix() { // Au départ, le prix est le prix de base double prixFinal = super.prix() ;
for (Accessoire acc : accessoires) { prixFinal += acc.prix(); } return prixFinal; } //.. }
Finalisation des Montre s
Pour finaliser la classe Montre
(mais sans mécanisme) :
I décidons d’un affichage :
Une montre composée de :
* bracelet cuir coûtant 54
* fermoir acier coûtant 12.
* etc.
==> Prix total : 147.
public void afficher () { System.out.print ("Une montre "); System.out.println("composée de :");
for (Accessoire acc : accessoires) { System.out.println(" * " + acc); } System.out.print ("==> Prix total : "); System.out.println(prix()); } //...
Un exemple de main()
public static void main(String[] args) { Montre m = new Montre();
m.ajouter(new Bracelet("cuir" , 54.0)); m.ajouter(new Fermoir ("acier" , 12.5)); m.ajouter(new Boitier ("acier" , 36.6)); m.ajouter(new Vitre ("quartz", 44.8));
System.out.println('\n' + "Montre m :");
m.afficher(); }
Montre m :
Une montre composée de :
* bracelet cuir coutant 54
* fermoir acier coutant 12.
* boitier acier coutant 36.
* vitre quartz coutant 44.
==> Prix total : 147.
Le code complet à ce stade (154 lignes) peut être téléchargé sur le site du cours :
https://d396qusza40orc.cloudfront.net/java-fr/complements/Montres01.java
Constructeurs des sous-classes
class MecanismeAnalogique extends Mecanisme { private int date; public MecanismeAnalogique(double valeurDeBase, String uneHeure, int uneDate) { super (valeurDeBase, uneHeure); date = uneDate; } } class MecanismeDigital extends Mecanisme { private String reveil; public MecanismeDigital(double valeurDeBase, String uneHeure, String heureRev) { super(valeurDeBase, uneHeure); reveil = heureRev; } } // ...
Constructeurs des sous-classes (suite)
class MecanismeDouble extends MecanismeAnalogique { private String reveil; public MecanismeDouble(double valeurDeBase, String uneHeure, int uneDate, String heureReveil) { super(valeurDeBase, uneHeure, uneDate); reveil = heureReveil; } }
Gestion de la valeur par défaut de la super-classe
class MecanismeDouble extends MecanismeAnalogique implements ReveilDigital {
public MecanismeDouble(double valeurDeBase, String uneHeure, int uneDate, String heureReveil) { super(valeurDeBase, uneHeure, uneDate); reveil = heureReveil; }
// gestion propre de la valeur par défaut de l'heure (super-classe) public MecanismeDouble(double valeurDeBase, int uneDate, String heureReveil) { super(valeurDeBase, uneDate); reveil = heureReveil; } }
Gestion de la valeur par défaut de la super-classe
public MecanismeDouble(double valeurDeBase, String uneHeure, int uneDate, String heureReveil) { super(valeurDeBase, uneHeure, uneDate); reveil = heureReveil; }
public // gestion propre de la valeur par défaut de l'heure (super-classe) MecanismeDouble(double valeurDeBase, int uneDate, String heureReveil) { super(valeurDeBase, uneDate); reveil = heureReveil; }
Construction d’une Montre
Complétons maintenant nos constructeurs pour la classe Montre :
class Montre extends Produit { private Mecanisme coeur; private ArrayList accessoires; //.. public Montre(Mecanisme depart) { coeur = depart; // nous y reviendrons accessoires = new ArrayList(); } //.. }
Affichage des Mecanisme s
Supposons que l’on veuille :
I que tous les mécanismes s’affichent suivant le même schéma, imposé et non
modifiable
Par exemple :
affichage du type de mécanisme, suivi d’un affichage du cadran (heure, date,
heure de réveil, ...), suivi du prix
I mais que chaque partie de ce schéma soit adaptable
I offrir une version par défaut, utilisable dans les sous-classes, de l’affichage du
cadran (par exemple affichage de l’heure)
I imposer la redéfinition de l’affichage du type de mécanisme
+ Comment faire?
Affichage des Mecanisme s : niveau général
abstract class Mecanisme extends Produit { //... // Tous les mécanismes DOIVENT s'afficher comme ceci public final String toString() { String result = "mécanisme "; result += toStringType(); result += " (affichage : "; result += toStringCadran(); result += "), prix : "; result += super.toString(); return result; } // on veut offrir la version par défaut aux sous-classes et aux classes // du même paquetage. Par défaut, on affiche juste l'heure. protected String toStringCadran() { return heure; } // Un mécanisme, ici à ce niveau, est abstrait (= classe abstraite) protected abstract String toStringType(); }
Affichage des Mecanisme s : sous-classes
class MecanismeDigital extends Mecanisme { //.. @Override protected String toStringType() { return "digital"; }
@Override protected String toStringCadran() { // On affiche l'heure (façon de base)... // ...et en plus l'heure de réveil. return super.toStringCadran() + ", " + toStringReveil(); }
protected String toStringReveil() { return " réveil " + reveil; } }
Test : un exemple de méthode main()
// test de l'affichage des mécanismes MecanismeAnalogique v1 = new MecanismeAnalogique(312.00, 20141212); MecanismeDigital v2 = new MecanismeDigital(32.00, "11:45", "7:00"); MecanismeDouble v3 = new MecanismeDouble(543.00, "8:20", 20140328, "6:30"); System.out.println(v1); System.out.println(v2); System.out.println(v3); // Test des montres Montre m = new Montre(new MecanismeDouble(468.00, "9:15", 20140401, "7:00")); m.ajouter(new Bracelet("cuir", 54.0)); m.ajouter(new Fermoir("acier", 12.5)); m.ajouter(new Boitier("acier", 36.60)); m.ajouter(new Vitre("quartz", 44.80)); System.out.println('\n' + "Montre m :"); m.afficher();
Le code complet à ce stade (298 lignes) peut être téléchargé sur le site du cours :
https://d396qusza40orc.cloudfront.net/java-fr/complements/Montres02.java
Copie de Montre
Montre maMontre = new Montre(...);
// votre ami veut la même montre // et dans ce cas on sait qu'il ne faut pas juste affecter // les références Montre montreToto = new Montre(maMontre);
Copie profonde
class Montre extends Produit { private Mecanisme coeur; private ArrayList accessoires; //... }
Si l’on veut faire des copies de Montres, on doit ici
faire une copie profonde :
copie de chaque constituant (mécanisme, acces-
soires)
Constructeur de copie
Copie de surface :
public Montre(Montre autre) { super(autre); coeur = autre.coeur; accessoires = autre.accessoires; }
Mais... comment copier chaque élément en tant que tel?
(et non pas comme une instance des super-classes Mecanisme et Accessoire)
+ copie polymorphique
Copie polymorphique
Pourquoi ceci ne suffit-il pas?
public Montre(Montre autre) { super(autre); coeur = new Mecanisme(autre.coeur); accessoires = new ArrayList(); for (Accessoire acc : autre.accessoires) { accessoires.add(new Accessoire(acc)); } }
Test : un exemple de main()
public static void main(String[] args) { // le reste comme avant
// Nous faisons une copie de la montre m Montre m2 = new Montre(m); System.out.println("Montre m2 :"); m2.afficher(); }
Le code complet à ce stade (415 lignes) peut être téléchargé sur le site du cours :
https://d396qusza40orc.cloudfront.net/java-fr/complements/Montres.java
