Obtenir le pack complet des cours, TD, TP et projets !
Êtes-vous un étudiant passionné d'informatique et souhaitez-vous maîtriser les Design Patterns ? Ne cherchez plus, nous avons le pack parfait pour vous.
Accédez à une collection complète de 75 supports de cours, de travaux dirigés (TD), de travaux pratiques (TP) et de projets concrets qui vous permettront de comprendre et d'appliquer efficacement les Design Patterns dans vos projets de développement, afin de créer des applications plus flexibles, maintenables et extensibles.
Obtenir le pack maintenantIUT Villetaneuse
M3105 : Conception et programmation objet avancées
Année 2016/2017, Formation Initiale
Correction TD5 : Le design pattern Composite
Nous allons utiliser le design pattern composite pour représenter et calculer des expressions
arithmétiques contenant des additions, soustractions, multiplications et/ou divisions.
Noter qu’une expression arithmétique peut se représenter sous la forme d’une arborescence,
par exemple (3+4) / (5 * (10-6)) correspond à l’arborescence :
Figure1 – Arborescence
I UML1 ◦
Dans un premier temps nous n’utiliserons pas le design pattern composite.
Sur l’arborescence précédente on constate qu’une opération possède deux types d’opérandes :
les nombres, représentés par les feuilles, et les opérations, représentées par les nœuds. Ainsi
dans l’opération 5 * (10 – 6), la première opérande est le nombre 5, et la seconde est l’opération10-6. a)Compléter le diagramme des classes suivant de façon a représenter toutes les situations possibles
concernant les 2 arguments des opérations :
Figure2 – Ebauche de diagramme
Noter qu’on doit utiliser un commentaire pour représenter le fait qu’une opération a exactement
2 opérandes.
Correction :3 b)Compléter le diagramme précédent de façon à munir les classes de 2 méthodes : valeur() qui
retourne une valeur de type double représentant la valeur du Nombre ou de l’Operation, et
une redéfinition de toString() retournant la représentation du Nombre ou de l’Operation.
Correction :3 2◦ Dans le cadre du design pattern composite on introduit une classe Expression dont les classes
Nombre et Operation héritent.
a)Modifier le diagramme de la question précédente en utilisant le design pattern composite. Tenir
compte du fait qu’on n’aura pas besoin d’ajouter ou retirer des opérandes puisque qu’une
opération possède toujours 2 opérandes.
Correction :3 b)Modifier le diagramme précédent en tenant compte des informations suivantes :
— La valeur d’un nombre est représentée par un attribut valeurNombre (la méthode valeur
retournera cette valeur).
— Ajouter un constructeur permettant d’initialiser un Nombre avec une valeur de typedouble. — Ajouter à Expression 2 méthodes getOperande1() et getOperande2() qui retournent
respectivement la première et la seconde opérande d’une Expression (par défaut on
retournera null afin de prendre en compte le fait que l’Expression courante peut être
nombre).
— Ajouter à Operation un constructeur permettant d’initialiser une opération avec 2 opé-
randes op1 et op2 qu’on affectera à deux variables operande1 et operande2.
— Redéfinir getOperande1() et getOperande2() dans Operation.
Correction :3 c)Donner les instructions de la méthode valeur() de la classe Addition qui retourne la valeur de
l’addition de ses deux opérandes. Indication : utiliser la méthode valeur() de chaque opérande.
Donner les instructions de la méthode toString() de cette même classe.
Correction :
Instructions :3 II Java
a)Traduire le diagramme des classes de la question c) en java et tester les programmes dans une
classe Calculatrice en faisant des opérations simples, puis en calculant l’expression numérique
donnée dans l’arborescence de la Figure1.
Correction :/** * Gestion d’une expression arithmetique*/ /**
* @author Dominique Bouthinon* */
public abstract class Expression{ // methodes definissant un comportement par defaut
// que les Nombre(s) et Operation(s) peuvent redéfinir
public Expression getOperande1()
{ return null ; }
public Expression getOperande2()
{ return null ;}
public double valeur()
{ return 0 ;}
public String toString()
{ return "" ;}} public class Nombre extends Expression{ private double valeurNombre ;
public Nombre(double uneValeur){ super() ;
this.valeurNombre = uneValeur ;} public double valeur()
{ return this.valeurNombre ;}
public String toString(){ // possible :
// return "" + this.valeurNombre ;
return Double.toString(this.valeurNombre) ;} }
// fin classe Nombre
public abstract class Operation extends Expression{ private Expression operande1 ;
private Expression operande2 ;/** * Initialise l’Operation avec les operandes op1 et op2*/ public Operation(Expression op1, Expression op2){ this.operande1 = op1 ;
this.operande2 = op2 ;} /**
* retourne la premiere operande de l’Operation binaire*/ public Expression getOperande1(){ return this.operande1 ;} /**
* retourne la seconde operande de l’Operation binaire*/ public Expression getOperande2(){ return this.operande2 ;} }
// fin classe Operation
public class Addition extends Operation{ /**
* @param op1
* @param op2*/ public Addition(Expression op1, Expression op2){ super(op1, op2);} /**
* retourn la valeur de l’addition*/ public double valeur(){ return this.getOperande1().valeur() + this.getOperande2().valeur() ;} /**
* retourne le String representant l’addition*/ public String toString(){ return "(" + this.getOperande1() + " + " + this.getOperande2() + ")" ;} }
public class Soustraction extends Operation{ /**
* @param op1
* @param op2*/ public Soustraction(Expression op1, Expression op2){ super(op1, op2);} /**
* retourn la valeur de la Soustraction*/ public double valeur(){ return this.getOperande1().valeur() - this.getOperande2().valeur() ;} /**
* retourne le String representant la Soustraction*/ public String toString(){ return "(" + this.getOperande1() + " - " + this.getOperande2() + ")" ;} }
public class Multiplication extends Operation{ /**
* @param op1
* @param op2*/ public Multiplication(Expression op1, Expression op2){ super(op1, op2);} /**
* retourn la valeur de la Multiplication*/ public double valeur(){ return this.getOperande1().valeur() * this.getOperande2().valeur() ;} /**
* retourne le String representant la Multiplication*/ public String toString(){ return "(" + this.getOperande1() + " * " + this.getOperande2() + ")" ;} }
public class Division extends Operation{ /**
* @param op1
* @param op2*/ public Division(Expression op1, Expression op2){ super( op1, op2);} /**
* retourn la valeur de la Division*/ public double valeur(){ return this.getOperande1().valeur() / this.getOperande2().valeur() ;} /**
* retourne le String representant la Division*/ public String toString(){ return "(" + this.getOperande1() + " / " + this.getOperande2() + ")" ;} }
public class Calculatrice{ public static void main(String[] args){ Expression trois = new Nombre(3) ;
Expression quatre = new Nombre(4) ;
Expression cinq = new Nombre(5) ;
Expression six
= new Nombre(6) ;
Expression dix
= new Nombre(10) ;
Expression s = new Soustraction(dix,six) ;
System.out.println(s + " = " + s.valeur()) ;
Expression a = new Addition(trois, quatre) ;
System.out.println(a + " = " + a.valeur()) ;
Expression m = new Multiplication(cinq, s) ;
System.out.println(m + " = " + m.valeur()) ;
Expression d = new Division(a, m) ;
System.out.println(d + " = " + d.valeur()) ;} }
// fin classe Calculatrice
3