DDeessiiggnn PPaatttteerrnnss 
PPaarrtt 88 
MMoohhaammeedd YYoouussssffii 
Laboratoire Signaux Systèmes Distribués et Inte...
PPaatttteerrnnss :: 
- SSttaatt 
-- TTTTeeeemmmmppppllllaaaatttteeee MMMMeeeetttthhhhoooodddd 
- CCoommmmaanndd 
- MMeeddi...
PPaatttteerrnn SSttaatt 
 Le comportement des méthodes d'un objet 
dépendent souvent de l‘état de celui-ci. 
 Cet état est...
EExxeemmppllee ddee pprroobbllèèmmee 
• Un avion peut être dans l'un des trois états suivants : 
• soit dans le garage, 
4...
PPaatttteerrnn SSttaatt 
 Catégorie : 
◦ Comportement 
 Objectif du pattern 
◦ CChhaannggeerr llee ccoommppoorrtteemmeennt...
Design pattern EEttaatt oouu SSttaattee 
 Le pattern Etat permet de déléguer le comportement 
d'un objet dans un autre obj...
RRaaiissoonn dd’’uuttiilliissaattiioonn 
 Un objet a un fonctionnement différent selon son état interne. Son 
état change ...
RReessppoonnssaabbiilliittééss 
 ClasseAvecEtat : est une classe avec état. Son 
comportement change en fonction de son ét...
Diagramme dd’’ééttaatt ttrraannssiittiioonn 
med@youssfi.net
IImmpplléémmeennttaattiioonn 
/* Etat.java */ 
public abstract class Etat { 
protected ClasseAvecEtat classeAvecEtat; 
pub...
IImmpplléémmeennttaattiioonn 
/* ClasseAvecEtat.java */ 
public class ClasseAvecEtat { 
private Etat etat; 
public ClasseA...
IImmpplléémmeennttaattiioonn 
/* EtatA.java */ 
public class EtatA extends Etat{ 
public EtatA(ClasseAvecEtat classeAvecEt...
IImmpplléémmeennttaattiioonn 
/* EtatA.java */ 
public class EtatB extends Etat{ 
public EtatB(ClasseAvecEtat classeAvecEt...
IImmpplléémmeennttaattiioonn 
/* EtatC.java */ 
public class EtatC extends Etat{ 
public EtatC(ClasseAvecEtat classeAvecEt...
IImmpplléémmeennttaattiioonn 
/* Application.java */ 
public class Application { 
public static void main(String[] args) {...
PPaatttteerrnn 
TTTTeeeemmmmppppllllaaaatttteeee MMMMeeeetttthhhhoooodddd
PPaatttteerrnn TTeemmppllaattee MMeetthhoodd 
 Catégorie : 
◦ Comportement 
 Objectif du pattern 
◦ Définir le squelette d...
RReessppoonnssaabbiilliittééss 
 TemplateClass: définit des méthodes 
abstraites primitives. La classe implémente le 
sque...
Design ppaatttteerrnn TTeemmppllaattee MMeetthhoodd 
19
IImmpplléémmeennttaattiioonn 
/* TemplateClass.java */ 
package tm; 
public abstract class TemplateClass { 
public int ope...
IImmpplléémmeennttaattiioonn 
/* Implementation1.java */ 
package tm; 
public class Implementation1 extends TemplateClass ...
IImmpplléémmeennttaattiioonn 
/* Implementation2.java */ 
package tm; 
public class Implementation2 extends TemplateClass{...
IImmpplléémmeennttaattiioonn 
/* Implementation2.java */ 
import tm.Implementation1; 
import tm.Implementation2; 
import t...
PPaatttteerrnn 
CCCCoooommmmmmmmaaaannnndddd
PPaatttteerrnn CCoommmmaanndd 
 Catégorie : 
◦ Comportement 
 Objectif du pattern 
◦ EEnnccaappssuulleerr uunnee rreeqquuê...
PPaatttteerrnn CCoommmmaanndd 
 Raison d’utilisation : 
◦ Le système doit traiter des requêtes. Ces requêtes peuvent 
prov...
RReessppoonnssaabbiilliittééss 
 Commande : définit l'interface d'une 
commande. 
 CommandeA et CommandeB : implémentent 
...
Design ppaatttteerrnn CCoommmmaanndd 
28
IImmpplléémmeennttaattiioonn 
/* Recepteur.java */ 
package cmd; 
public class Recepteur { 
public void action1(){ 
System...
IImmpplléémmeennttaattiioonn 
package cmd; 
public interface Commande { 
public void executer(); 
} 
/* Commande.java */ 
...
IImmpplléémmeennttaattiioonn 
/* CommandeB.java */ 
package cmd; 
public class CommandeB implements Commande { 
private Re...
IImmpplléémmeennttaattiioonn 
/* Invoqueur.java */ 
package cmd; 
import java.util.HashMap; 
import java.util.Map; 
public...
IImmpplléémmeennttaattiioonn 
/* Application.java */ 
package cmd; 
public class Application { 
public static void main(St...
PPaatttteerrnn 
MMMMeeeeddddiiiiaaaattttoooorrrr
Exemple (contrôle dduu ttrraaffiicc aaéérriieenn))
SSoolluuttiioonn ::
PPaatttteerrnn MMeeddiiaattoorr 
 Catégorie : 
◦ Comportement 
 Objectif du pattern 
◦ Gérer la transmission d'information...
PPaatttteerrnn MMeeddiiaattoorr 
 Raison d’utilisation : 
◦ Différents objets ont des interactions. Un 
événement sur l'un...
RReessppoonnssaabbiilliittééss 
 Collegue : définit l'interface d'un collègue. Il s'agit 
d'une famille d'objets qui s'ign...
DDeessiiggnn ppaatttteerrnn MMeeddiiaattoorr 
40
IImmpplléémmeennttaattiioonn 
/* Message.java */ 
package med; 
public class Message { 
private String message; private St...
IImmpplléémmeennttaattiioonn 
/* mediateur.java */ 
package med; 
import java.util.HashMap; 
import java.util.Map; 
public...
IImmpplléémmeennttaattiioonn 
/* Collegue.java */ 
package med; 
public abstract class Collegue { 
protected String name; ...
IImmpplléémmeennttaattiioonn 
/* MediateurImpl.java */ 
package med; 
import java.util.ArrayList; import java.util.List; 
...
IImmpplléémmeennttaattiioonn 
/* CollegueA.java */ 
package med; 
public class CollegueA extends Collegue { 
public Colleg...
IImmpplléémmeennttaattiioonn 
/* CollegueB.java */ 
package med; 
public class CollegueB extends Collegue { 
public Colleg...
IImmpplléémmeennttaattiioonn 
/* Application.java */ 
import med.*; 
public class Application { 
public static void main(S...
Prochain SlideShare
Chargement dans…5
×

Cours design pattern m youssfi partie 8 stat, template method, command , mediator

4 717 vues

Publié le

Design patterns :
- Stat
- Template Method
- Command
- Mediator

Publié dans : Logiciels
1 commentaire
4 j’aime
Statistiques
Remarques
Aucun téléchargement
Vues
Nombre de vues
4 717
Sur SlideShare
0
Issues des intégrations
0
Intégrations
14
Actions
Partages
0
Téléchargements
712
Commentaires
1
J’aime
4
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Cours design pattern m youssfi partie 8 stat, template method, command , mediator

  1. 1. DDeessiiggnn PPaatttteerrnnss PPaarrtt 88 MMoohhaammeedd YYoouussssffii Laboratoire Signaux Systèmes Distribués et Intelligence Artificielle (SSDIA) ENSET, Université Hassan II Casablanca, Maroc Email : med@youssfi.net Supports de cours : http://fr.slideshare.net/mohamedyoussfi9 Chaîne vidéo : http://youtube.com/mohamedYoussfi Recherche : http://www.researchgate.net/profile/Youssfi_Mohamed/publications med@youssfi.net
  2. 2. PPaatttteerrnnss :: - SSttaatt -- TTTTeeeemmmmppppllllaaaatttteeee MMMMeeeetttthhhhoooodddd - CCoommmmaanndd - MMeeddiiaattoorr
  3. 3. PPaatttteerrnn SSttaatt Le comportement des méthodes d'un objet dépendent souvent de l‘état de celui-ci. Cet état est en général représente par les attributs de l'objet. Cependant, plus l'objet peut prendre d‘états comportementaux distincts, plus la structuration de l'objet est complexe. Le design pattern état est la meilleure solution pour bien structurer et représenter les différents états d'un objet ainsi que les transitions entre ces états sous une forme orientée objet. med@youssfi.net
  4. 4. EExxeemmppllee ddee pprroobbllèèmmee • Un avion peut être dans l'un des trois états suivants : • soit dans le garage, 4 • soit sur la piste, • soit en l'air. • Lorsqu'il est dans le garage, la méthode sortirDuGarage permet de passer dans l‘état sur la piste . • Lorsqu'il est sur la piste, la méthode entrerAuGarage permet de passer dans l‘état dans le garage • La méthode décoller permet de passer dans l‘état en l'air. • Lorsqu'il est en l'air, la méthode atterrir permet de passer dans l‘état sur la piste. • Les autres combinaisons Etats - Méthodes génèrent une erreur comme par exemple, invoquer décoller lorsque l'avion est dans le garage.
  5. 5. PPaatttteerrnn SSttaatt Catégorie : ◦ Comportement Objectif du pattern ◦ CChhaannggeerr llee ccoommppoorrtteemmeenntt dd''uunn oobbjjeett sseelloonn ssoonn ééttaatt interne. Résultat : ◦ Le Design Pattern permet d'isoler les algorithmes propres à chaque état d'un objet. med@youssfi.net
  6. 6. Design pattern EEttaatt oouu SSttaattee Le pattern Etat permet de déléguer le comportement d'un objet dans un autre objet. Cela permet de changer le comportement de l'objet en cours d'exécution et de simuler un changement de classe. 6
  7. 7. RRaaiissoonn dd’’uuttiilliissaattiioonn Un objet a un fonctionnement différent selon son état interne. Son état change selon les méthodes appelées. Cela peut être un document informatique. Il a comme fonctions ouvrir, modifier, sauvegarder ou fermer. Le comportement de ces méthodes change selon l'état du document. LLeess ddiifffféérreennttss ééttaattss iinntteerrnneess ssoonntt cchhaaccuunn rreepprréésseennttéé ppaarr uunnee ccllaassssee état (ouvert, modifié, sauvegardé et fermé). Les états possèdent des méthodes permettant de réaliser les opérations et de changer d'état (ouvrir, modifier,sauvegarder et fermer). Certains états bloquent certaines opérations (modifier dans l'état fermé). L'objet avec état maintient une référence vers l'état actuel. Il présente les opérations à la partie cliente. med@youssfi.net
  8. 8. RReessppoonnssaabbiilliittééss ClasseAvecEtat : est une classe avec état. Son comportement change en fonction de son état. La partie changeante de son comportement est déléguée à un objet Etat. Etat : définit l'interface d'un comportement d'un état. EEttaattAA,, EEttaattBB eett EEttaattCC :: ssoonntt ddeess ssoouuss--ccllaasssseess ccoonnccrrèètteess de l'interface Etat. Elles implémentent des méthodes qui sont associées à un Etat. med@youssfi.net
  9. 9. Diagramme dd’’ééttaatt ttrraannssiittiioonn med@youssfi.net
  10. 10. IImmpplléémmeennttaattiioonn /* Etat.java */ public abstract class Etat { protected ClasseAvecEtat classeAvecEtat; public Etat(ClasseAvecEtat classeAvecEtat) { this.classeAvecEtat = classeAvecEtat; } public abstract void operationEtatA(); public abstract void operationEtatB(); public abstract void operationEtatC(); public abstract void doAction(); } med@youssfi.net
  11. 11. IImmpplléémmeennttaattiioonn /* ClasseAvecEtat.java */ public class ClasseAvecEtat { private Etat etat; public ClasseAvecEtat() { etat=new EtatA(this); } public void operationEtatA() { etat.operationEtatA();} public void operationEtatB() { etat.operationEtatB(); } public void operationEtatC() { etat.operationEtatC(); } public void doAction() { etat.doAction(); } public Etat getEtat() { return etat; } public void setEtat(Etat etat) { this.etat = etat; } } med@youssfi.net
  12. 12. IImmpplléémmeennttaattiioonn /* EtatA.java */ public class EtatA extends Etat{ public EtatA(ClasseAvecEtat classeAvecEtat) {super(classeAvecEtat); } @Override public void operationEtatA() { System.out.println(Classe déjà dans l'état A); } @Override public void operationEtatB() { classeAvecEtat.setEtat(new EtatB(classeAvecEtat)); System.out.println(Changement d'état de A=B); } @Override public void operationEtatC() { System.out.println(Impossible de passer de A =C); } @Override public void doAction() { System.out.println(Etat courant : A); } } med@youssfi.net
  13. 13. IImmpplléémmeennttaattiioonn /* EtatA.java */ public class EtatB extends Etat{ public EtatB(ClasseAvecEtat classeAvecEtat) { super(classeAvecEtat);} @Override public void operationEtatA() { System.out.println(Pas de possible de passer de B vers A); } @Override public void operationEtatB() { System.out.println(Déjà dans l'état B); } @Override public void operationEtatC() { classeAvecEtat.setEtat(new EtatC(classeAvecEtat)); System.out.println(Changement d'état de B vers C); } @Override public void doAction() { System.out.println(Etat courant : B); } } med@youssfi.net
  14. 14. IImmpplléémmeennttaattiioonn /* EtatC.java */ public class EtatC extends Etat{ public EtatC(ClasseAvecEtat classeAvecEtat) { super(classeAvecEtat); } @Override public void operationEtatA() { System.out.println(Changement d'état de C vers A); classeAvecEtat.setEtat(new EtatA(classeAvecEtat)); } @Override public void operationEtatB() { System.out.println(Changement d'état de C vers B); classeAvecEtat.setEtat(new EtatB(classeAvecEtat)); } @Override public void operationEtatC() { System.out.println(Déjà dans l'état C); } @Override public void doAction() { System.out.println(Etat courant : C); } }
  15. 15. IImmpplléémmeennttaattiioonn /* Application.java */ public class Application { public static void main(String[] args) { ClasseAvecEtat obj=new ClasseAvecEtat(); obj.doAction(); System.out.println(-------------); obj.operationEtatA(); obj.doAction();System.out.println(-------------); obj.operationEtatC(); obj.doAction();System.out.println(-------------); obj.operationEtatB(); obj.doAction();System.out.println(-------------); obj.operationEtatC(); obj.doAction();System.out.println(-------------); obj.operationEtatA(); obj.doAction();System.out.println(-------------); } } Etat courant : A ------------- Classe déjà dans l'état A Etat courant : A ------------- Impossible de passer de A =C Etat courant : A ------------- Changement d'état de A=B Etat courant : B ------------- Changement d'état de B vers C Etat courant : C ------------- Changement d'état de C vers A Etat courant : A -------------
  16. 16. PPaatttteerrnn TTTTeeeemmmmppppllllaaaatttteeee MMMMeeeetttthhhhoooodddd
  17. 17. PPaatttteerrnn TTeemmppllaattee MMeetthhoodd Catégorie : ◦ Comportement Objectif du pattern ◦ Définir le squelette d'un algorithme en déléguant certaines étapes à des sous-classes. RRééssuullttaatt :: ◦ Le Design Pattern permet d'isoler les parties variables d'un algorithme. Raisons d’utilisation : ◦ Une classe possède un fonctionnement global, mais les détails de son algorithme doivent être spécifiques à ses sous-classes. med@youssfi.net
  18. 18. RReessppoonnssaabbiilliittééss TemplateClass: définit des méthodes abstraites primitives. La classe implémente le squelette d'un algorithme qui appelle les méthodes primitives. IImmpplleennttaattiioonn11,, IImmpplleemmeennttaattiioonn22 :: ssoonntt des sous-classes concrète de TemplateClass. Elle implémente les méthodes utilisées par l'algorithme de la méthode operationTemplate() de TemplateClass. La partie cliente appelle la méthode de TemplateClass qui définit l'algorithme. med@youssfi.net
  19. 19. Design ppaatttteerrnn TTeemmppllaattee MMeetthhoodd 19
  20. 20. IImmpplléémmeennttaattiioonn /* TemplateClass.java */ package tm; public abstract class TemplateClass { public int operationTemplate(){ int a=operationAbs1(); int somme=0; for(int i=0;ia;i++){ somme+=operationAbs2(); } return somme; } protected abstract int operationAbs1(); protected abstract int operationAbs2(); } med@youssfi.net
  21. 21. IImmpplléémmeennttaattiioonn /* Implementation1.java */ package tm; public class Implementation1 extends TemplateClass { @Override protected int operationAbs1() { return 8; } @Override protected int operationAbs2() { return 12; } } med@youssfi.net
  22. 22. IImmpplléémmeennttaattiioonn /* Implementation2.java */ package tm; public class Implementation2 extends TemplateClass{ @Override protected int operationAbs1() { return 34; } @Override protected int operationAbs2() { // TODO Auto-generated method stub return 56; } } med@youssfi.net
  23. 23. IImmpplléémmeennttaattiioonn /* Implementation2.java */ import tm.Implementation1; import tm.Implementation2; import tm.TemplateClass; public class Application { public static void main(String[] args) { TemplateClass t1=new Implementation1(); System.out.println(t1.operationTemplate()); t1=new Implementation2(); System.out.println(t1.operationTemplate()); } } med@youssfi.net 96 1904
  24. 24. PPaatttteerrnn CCCCoooommmmmmmmaaaannnndddd
  25. 25. PPaatttteerrnn CCoommmmaanndd Catégorie : ◦ Comportement Objectif du pattern ◦ EEnnccaappssuulleerr uunnee rreeqquuêêttee ssoouuss llaa ffoorrmmee dd'' oobbjjeett.. ◦ Paramétrer facilement des requêtes diverses. ◦ Permettre des opérations réversibles. Résultat : ◦ Le Design Pattern permet d'isoler une requête. med@youssfi.net
  26. 26. PPaatttteerrnn CCoommmmaanndd Raison d’utilisation : ◦ Le système doit traiter des requêtes. Ces requêtes peuvent provenir de plusieurs émetteurs. ◦ Plusieurs émetteurs peuvent produire la même requête. ◦ Les requêtes doivent pouvoir être annulées. ◦ Cela peut être le cas d'une IHM avec des boutons de commande, ddeess rraaccccoouurrcciiss ccllaavviieerr eett ddeess cchhooiixx ddee mmeennuu aabboouuttiissssaanntt àà llaa même requête. ◦ La requête est encapsulée dans un objet : la commande. ◦ Chaque commande possède un objet qui traitera la requête : le récepteur. ◦ La commande ne réalise pas le traitement, elle est juste porteuse de la requête. ◦ Les émetteurs potentiels de la requête (éléments de l'IHM) sont des invoqueurs. ◦ Plusieurs invoqueurs peuvent se partager la même commande. med@youssfi.net
  27. 27. RReessppoonnssaabbiilliittééss Commande : définit l'interface d'une commande. CommandeA et CommandeB : implémentent une commande. Chaque classe implémente la méthode executer(), en appelant des méthodes de ll''oobbjjeett RReecceepptteeuurr.. Invoqueur : déclenche la commande. Il appelle la méthode executer() d'un objet Commande. Recepteur : reçoit la commande et réalise les opérations associées. Chaque objet Commande concret possède un lien avec un objet Recepteur. La partie cliente configure le lien entre les objets Commande et le Recepteur. med@youssfi.net
  28. 28. Design ppaatttteerrnn CCoommmmaanndd 28
  29. 29. IImmpplléémmeennttaattiioonn /* Recepteur.java */ package cmd; public class Recepteur { public void action1(){ System.out.println(Action 1 du récepteur); } public void action2(){ System.out.println(Action 2 du récepteur); } } med@youssfi.net
  30. 30. IImmpplléémmeennttaattiioonn package cmd; public interface Commande { public void executer(); } /* Commande.java */ /* CommandeA.java */ package cmd; public class CommandeA implements Commande { private Recepteur recepteur; public CommandeA(Recepteur recepteur) { med@youssfi.net this.recepteur = recepteur; } @Override public void executer() { recepteur.action1(); } }
  31. 31. IImmpplléémmeennttaattiioonn /* CommandeB.java */ package cmd; public class CommandeB implements Commande { private Recepteur recepteur; public CommandeB(Recepteur recepteur) { this.recepteur = recepteur; } @Override med@youssfi.net public void executer() { recepteur.action2(); } }
  32. 32. IImmpplléémmeennttaattiioonn /* Invoqueur.java */ package cmd; import java.util.HashMap; import java.util.Map; public class Invoqueur { private MapString, Commande commades=new HashMapString, Commande(); public void addCommande(String cmdName,Commande cmd){ med@youssfi.net commades.put(cmdName, cmd); } public void invoquer(String cmdName){ Commande cmd=commades.get(cmdName); if (cmd!=null) cmd.executer(); } }
  33. 33. IImmpplléémmeennttaattiioonn /* Application.java */ package cmd; public class Application { public static void main(String[] args) { Recepteur rec=new Recepteur(); CommandeA commandeA=new CommandeA(rec); CommandeB commandeB=new CommandeB(rec); Invoqueur invoqueur=new Invoqueur(); invoqueur.addCommande(CA, commandeA); invoqueur.addCommande(CB, commandeB); invoqueur.invoquer(CA);invoqueur.invoquer(CB); invoqueur.invoquer(CC); } } med@youssfi.net Action 1 du récepteur Action 2 du récepteur
  34. 34. PPaatttteerrnn MMMMeeeeddddiiiiaaaattttoooorrrr
  35. 35. Exemple (contrôle dduu ttrraaffiicc aaéérriieenn))
  36. 36. SSoolluuttiioonn ::
  37. 37. PPaatttteerrnn MMeeddiiaattoorr Catégorie : ◦ Comportement Objectif du pattern ◦ Gérer la transmission d'informations entre des objets iinntteerraaggiissssaanntt eennttrree eeuuxx.. ◦ Avoir un couplage faible entre les objets puisqu'ils n'ont pas de lien direct entre eux. ◦ Pouvoir varier leur interaction indépendamment. Résultat : ◦ Le Design Pattern permet d'isoler la communication entre des objets. med@youssfi.net
  38. 38. PPaatttteerrnn MMeeddiiaattoorr Raison d’utilisation : ◦ Différents objets ont des interactions. Un événement sur l'un provoque une action ou des actions sur un autre ou d'autres objets. ◦ Besoin de centraliser le contrôle et les ccoommmmuunniiccaattiioonnss ccoommpplleexxeess eennttrree oobbjjeettss apparentés. ◦ Construire un objet dont la vocation est la gestion et le contrôle des interactions complexes entre un ensemble d’objets sans que les éléments doivent se connaître mutuellement. med@youssfi.net
  39. 39. RReessppoonnssaabbiilliittééss Collegue : définit l'interface d'un collègue. Il s'agit d'une famille d'objets qui s'ignorent entre eux mais qui doivent se transmettre des informations. CollegueA et CollegueB : sont des sous-classes concrètes de l'interface Collegue. EElllleess oonntt uunnee rrééfféérreennccee ssuurr uunn oobbjjeett MMeeddiiaatteeuurr auquel elles transmettront les informations. Mediateur : définit l'interface de communication entre les objets Collegue. ConcreteMediateur : implémente la communication et maintient une référence sur les objets Collegue. med@youssfi.net
  40. 40. DDeessiiggnn ppaatttteerrnn MMeeddiiaattoorr 40
  41. 41. IImmpplléémmeennttaattiioonn /* Message.java */ package med; public class Message { private String message; private String expediteur; private String destinataire; public Message() { } public Message(String message, String destinataire) { this.message = message; this.destinataire = destinataire; } @Override public String toString() { return Message [message= + message + , expediteur= + expediteur + , destinataire= + destinataire + ]; } // Getters et Setters } med@youssfi.net
  42. 42. IImmpplléémmeennttaattiioonn /* mediateur.java */ package med; import java.util.HashMap; import java.util.Map; public abstract class Mediateur { protected MapString, Collegue collegues=new HashMapString, Collegue(); public abstract void transmettreMessage(Message m); public void addCollegue(String ref,Collegue a){ collegues.put(ref, a); } } med@youssfi.net
  43. 43. IImmpplléémmeennttaattiioonn /* Collegue.java */ package med; public abstract class Collegue { protected String name; protected Mediateur mediateur; public Collegue(String name,Mediateur mediateur) { this.name=name; this.mediateur = mediateur; mediateur.addCollegue(name, this); } public abstract void envoyerMessage(Message m); public abstract void recevoirMessage(Message m); } med@youssfi.net
  44. 44. IImmpplléémmeennttaattiioonn /* MediateurImpl.java */ package med; import java.util.ArrayList; import java.util.List; public class MediateurImpl1 extends Mediateur { private ListMessage conversations=new ArrayListMessage(); @Override public void transmettreMessage(Message m) { System.out.println(--------- Début Médiateur ----------); System.out.println(Enregistrement du message); conversations.add(m); System.out.println(Transmission du message); System.out.println(From :+m.getExpediteur()); System.out.println(To:+m.getDestinataire()); Collegue destinataire=collegues.get(m.getDestinataire()); destinataire.recevoirMessage(m); System.out.println(--------- Fin Médiateur ----------); } public void analyserConversation(){ for(Message m:conversations) System.out.println(m.toString()); } } med@youssfi.net
  45. 45. IImmpplléémmeennttaattiioonn /* CollegueA.java */ package med; public class CollegueA extends Collegue { public CollegueA(String name,Mediateur mediateur) { super(name,mediateur); } @Override public void envoyerMessage(Message m) { System.out.println(----------------------); System.out.println(Collègue nom=+name+, Envoi de message); m.setExpediteur(this.name); mediateur.transmettreMessage(m); med@youssfi.net System.out.println(----------------------); } @Override public void recevoirMessage(Message m) { System.out.println(----------------------); System.out.println(Collègue nom=+name+, Réception du message); System.out.println(From :+m.getExpediteur()); System.out.println(Contenu:+m.getMessage()); System.out.println(Traitement du message par .....+this.name); System.out.println(-------------------); } }
  46. 46. IImmpplléémmeennttaattiioonn /* CollegueB.java */ package med; public class CollegueB extends Collegue { public CollegueB(String name,Mediateur mediateur) { super(name,mediateur); } @Override public void envoyerMessage(Message m) { System.out.println(----------------------); System.out.println(Collègue nom=+name+, Envoi de message); m.setExpediteur(this.name); mediateur.transmettreMessage(m); med@youssfi.net System.out.println(----------------------); } @Override public void recevoirMessage(Message m) { System.out.println(----------------------); System.out.println(Collègue nom=+name+, Réception du message); System.out.println(From :+m.getExpediteur()); System.out.println(Contenu:+m.getMessage()); System.out.println(Traitement du message par .....+this.name); System.out.println(-------------------); } }
  47. 47. IImmpplléémmeennttaattiioonn /* Application.java */ import med.*; public class Application { public static void main(String[] args) { MediateurImpl1 mediateur=new MediateurImpl1(); Collegue a1=new CollegueA(C1,mediateur); Collegue a2=new CollegueA(C2,mediateur); Collegue b1=new CollegueB(C3,mediateur); a1.envoyerMessage(new Message(je suis à 20 m,C2)); } } med@youssfi.net ---------------------- Collègue nom=C1, Envoi de message --------- Début Médiateur ---------- Enregistrement du message Transmission du message From :C1 To:C2 ---------------------- Collègue nom=C2, Réception du message From :C1 Contenu:je suis à 20 m Traitement du message par .....C2 ------------------- --------- Fin Médiateur ---------- ----------------------

×