19中介者模式

中介者模式

<设计模式其实很简单>笔记

①定义：

用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显示地互相引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

②代码：

//抽象中介者
public abstract class Mediator{
	public abstract void Send(String message , Colleague colleague);
}
//具体中介者
public class ConcreteMediator extends Mediator{
	private ConcreteColleagueA colleagueA;
	private ConcreteColleagueB colleagueB;
	
	//覆盖父类的抽象方法
	//转发信息给同事
	public void Send(String message , Colleague colleague){
		if(colleague == colleagueA){
			colleagueB.Notify(message);			
		}else{
			colleagueA.Notify(message);
		}
	}
	//设定同事A
	public void setColleagueA(ConcreteColleagueA colleagueA){
		this.colleagueA = colleagueA;
	}
	//设定同事B
	public void setColleagueA(ConcreteColleagueB colleagueB){
		this.colleagueB = colleagueB;
	}
}
//抽象的同时类
public abstract class Colleague{
	protected Mediator mediator;
	//构造函数
	public Colleague(Mediator mediator){
		this.mediator  = mediator;
	}
}
//具体同事A
public class ConcreteColleagueA extends Colleague{
	public ConcreteColleagueA(Mediator mediator){
		super(mediator);
	}
	//转发信息给同事A
	public void Send(String message){
		mediator.Send(message , this);
	}
	//收信通知
	public void Notify(String message){
		System.out.println("colleague A gor a message : " + message);
	}
}
//具体同事B
public class ConcreteColleagueB extends Colleague{
	public ConcreteColleagueB(Mediator mediator){
		super(mediator);
	}
	//转发信息给同事B
	public void Send(String message){
		mediator.Send(message , this);
	}
	//收信通知
	public void Notify(String message){
		System.out.println("colleague B gor a message : " + message);
	}
}
//客户端
public static void main(String[] args){
	ConcreteMediator concreteMediator = new ConcreteMediator();
	ConcreteColleagueA CA = new ConcreteColleagueA(concreteMediator);
	ConcreteColleagueB CB = new ConcreteColleagueB(concreteMediator);
	
	concreteMediator.setColleagueA(CA)
	concreteMediator.setColleagueA(CB);
	
	CA.Send("Hello , I am A");
	CB.Send("I am B , How do you do");
}
//同事A和B不知道对方的存在。

③适用的地方：
当一组对象以定义良好但是复杂的方式通信时，所产生的相互依赖关系结构混乱并且难以理解，这时就需要中介者模式。
当一个对象要引用很多其他的对象并且直接与这些对象通信导致难以复用该对象时。
当开发人员想要定制一个分布在多个类中的行为但是却不想生成太多的子类时。