行为型模式之中介者模式

 
一.定义
　　中介者模式(Mediator Pattern)定义：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

二、模式结构成员构成

• Mediator: 抽象中介者

• ConcreteMediator: 具体中介者

• Colleague: 抽象同事类

• ConcreteColleague: 具体同事类

 

三.代码示例
  1 /**
  2  * Colleague
  3  * 抽象同事类
  4  */
  5 public abstract class AbstractColleague {
  6     protected int number;
  7 
  8     public int getNumber() {
  9         return number;
 10     }
 11 
 12     public void setNumber(int number) {
 13         this.number = number;
 14     }
 15 
 16     //注意这里的参数不再是同事类，而是一个中介者
 17     public abstract void setNumber(int number, AbstractMediator am);
 18 }
 19 
 20 /**
 21  * ConcreteColleague
 22  * 具体同事类
 23  */
 24 public class ColleagueA extends AbstractColleague {
 25 
 26     @Override
 27     public void setNumber(int number, AbstractMediator am) {
 28         this.number = number;
 29         am.AaffectB();
 30     }
 31 
 32 }
 33 
 34 /**
 35  * ConcreteColleague
 36  * 具体同事类
 37  */
 38 public class ColleagueB extends AbstractColleague{
 39  
 40     @Override
 41     public void setNumber(int number, AbstractMediator am) {
 42         this.number = number;
 43         am.BaffectA();
 44     }
 45 }
 46 
 47 /**
 48  * Mediator
 49  * 抽象中介者
 50  */
 51 public abstract class AbstractMediator {
 52     protected AbstractColleague A;
 53     protected AbstractColleague B;
 54     
 55     public AbstractMediator(AbstractColleague a, AbstractColleague b) {
 56         A = a;
 57         B = b;
 58     }
 59  
 60     public abstract void AaffectB();
 61     
 62     public abstract void BaffectA();
 63  
 64 }
 65 
 66 /**
 67  * ConcreteMediator
 68  * 具体中介者
 69  */
 70 class Mediator extends AbstractMediator {
 71 
 72     public Mediator(AbstractColleague a, AbstractColleague b) {
 73         super(a, b);
 74     }
 75 
 76     //处理A对B的影响
 77     @Override
 78     public void AaffectB() {
 79         int number = A.getNumber();
 80         B.setNumber(number * 100);
 81     }
 82 
 83     //处理B对A的影响
 84     @Override
 85     public void BaffectA() {
 86         int number = B.getNumber();
 87         A.setNumber(number / 100);
 88     }
 89 }
 90 
 91 /**
 92  * client
 93  */
 94 public class Client {
 95     public static void main(String[] args){
 96         AbstractColleague collA = new ColleagueA();
 97         AbstractColleague collB = new ColleagueB();
 98         
 99         AbstractMediator am = new Mediator(collA, collB);
100         
101         System.out.println("==========通过设置A影响B==========");
102         collA.setNumber(1000, am);
103         System.out.println("collA的number值为："+collA.getNumber());
104         System.out.println("collB的number值为A的10倍："+collB.getNumber());
105  
106         System.out.println("==========通过设置B影响A==========");
107         collB.setNumber(1000, am);
108         System.out.println("collB的number值为："+collB.getNumber());
109         System.out.println("collA的number值为B的0.1倍："+collA.getNumber());
110         
111     }
112 }
View Code

 

四.优点和缺点分析
优点：
>简化了对象之间的交互
>将各同事解耦

缺点：
>可能会导致中介者对象非常复杂，使得系统难以维护。
 
五.应用场景
>想通过一个中间类来封装多个类中的行为

>系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。

>一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。

 

posted @ 2018-07-01 19:55  N!CE波  阅读(187)  评论(0)  编辑  收藏  举报