设计模式学习笔记（26）——中介者模式实现

一、中介者模式

package operation;
//抽象中介者类,定义一个抽象的发送消息的方法，得到同事对象和发送的消息
abstract class Mediator{
	
	public abstract void Send(String message,Colleague colleague);
}
//抽象同事类
abstract class Colleague{
	protected Mediator mediator;
	public Colleague(Mediator mediator) {
		this.mediator=mediator;
	}
}
//具体中介者类
class ConcreteMediator extends Mediator{
	//需要了解所有的具体同事对象
	private ConcreteColleague1 colleague1;
	private ConcreteColleague2 colleague2;
	public ConcreteColleague1 getColleague1() {
		return colleague1;
	}
	public ConcreteColleague2 getColleague2() {
		return colleague2;
	}
	public void setColleague2(ConcreteColleague2 colleague2) {
		this.colleague2 = colleague2;
	}
	public void setColleague1(ConcreteColleague1 colleague1) {
		this.colleague1 = colleague1;
	}
	@Override
	public void Send(String message, Colleague colleague) {
		// TODO Auto-generated method stub
		if(colleague==colleague1) {
			colleague2.Notify(message);
		}else {//重写发送信息的方法，根据对象作出选择判断，通知对象
			colleague1.Notify(message);
		}
	}
	
}
//同事对象
class ConcreteColleague1 extends Colleague{
	public ConcreteColleague1(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	public void Send(String message) {
		mediator.Send(message, this);//concretecolleague1发送message
	}
	public void Notify(String message) {
		System.out.println("同事1得到消息："+message);
	}
}
class ConcreteColleague2 extends Colleague{
	public ConcreteColleague2(Mediator mediator) {
		super(mediator);
		// TODO Auto-generated constructor stub
	}
	public void Send(String message) {
		mediator.Send(message, this);
	}
	public void Notify(String message) {
		System.out.println("同事2得到消息："+message);//concretecolleague2发送message
	}
}

public class Main{
	public static void main(String[] args){
		ConcreteMediator m=new ConcreteMediator();
		ConcreteColleague1 c1=new ConcreteColleague1(m);//让两个具体同事类认识中介者对象
		ConcreteColleague2 c2=new ConcreteColleague2(m);
		m.setColleague1(c1);
		m.setColleague2(c2);//让中介者认识各个具体同事类
		c1.Send("吃饭了吗？");
		c2.Send("没有呢，一起？");//具体同事类对象发送消息都是通过中介者转发
	}
}

二、安理会做中介

package operation;
//联合国机构
abstract class UnitedNations{
	//声明
	public abstract void Declare(String message,Country colleague);
}
//国家
abstract class Country{
	protected UnitedNations mediator;
	public Country(UnitedNations mediator) {
		this.mediator=mediator;
	}
}

//美国
class USA extends Country{

	public USA(UnitedNations mediator) {
		super(mediator);
		
	}
	//声明
	public void Declare(String message) {
		mediator.Declare(message, this);
	}
	//获得消息
	public void GetMessage(String message) {
		System.out.println("美国获得对方消息："+message);
	}
}

//伊拉克
class Iraq extends Country{

	public Iraq(UnitedNations mediator) {
		super(mediator);
		
	}
	//声明
	public void Declare(String message) {
		mediator.Declare(message, this);
	}
	//获取消息
	public void GetMessage(String message) {
		System.out.println("伊拉克获得对方消息："+message);
	}
}
//联合国安全理事会
class UnitedNationsSecurity extends UnitedNations{
	private USA colleague1;
	private Iraq colleague2;
	//美国
	public USA getColleague1() {
		return colleague1;
	}
	//伊拉克
	public Iraq getColleague2() {
		return colleague2;
	}
	public void setColleague2(Iraq colleague2) {
		this.colleague2 = colleague2;
	}
	public void setColleague1(USA colleague1) {
		this.colleague1 = colleague1;
	}
	//声明，重写了声明方法，实现了两个对象的通信
	@Override
	public void Declare(String message, Country colleague) {
		// TODO Auto-generated method stub
		if(colleague==colleague1) {
			colleague2.GetMessage(message);
		}else {
			colleague1.GetMessage(message);
		}
	}
	
}
public  class Main{
	public static void main(String[] args){
		UnitedNationsSecurity UNSC=new UnitedNationsSecurity();
		USA c1=new USA(UNSC);
		Iraq c2=new Iraq(UNSC);
		UNSC.setColleague1(c1);
		UNSC.setColleague2(c2);
		c1.Declare("不准研发核武器，否则要发动战争！");
		c2.Declare("我们没有核武器，也不怕侵略！");
	}
}

三、中介者模式优缺点
优点：
1.Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator。
2.由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度看待系统

缺点：
控制的集中化把交互复杂性变为了中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague都复杂。