设计模式：中介者模式

 

 

一 .什么是中介者模式：

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

二.中介者模式中的角色：

    Mediator：抽象中介者角色，抽象中介者角色定义统一的接口，用于各同事角色之间的通信。

    ConcreteMediator:具体中介者角色，具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。

    Colleague：抽象同事类。

    ConcreteColleague: 具体同事类。每个具体同事类都只需要知道自己的行为(一种是同事本身的行为，自发的，另一种是必须依赖中介者才能完成的行为），他们都需要认识中介者。

 

三.举例（进销存实例）

    Purchase购买类    Sell销售类    Stock库存类

1）没有使用中介者模式

//购买类 
class Purchase {

	void buy(int num,Stock sto){  //购买num件物品
		sto.stock += num;
		System.out.println("买入了："+num);
	}
}

//销售类 
class Sell {
	void sell(int num,Stock sto,Purchase pur){    //销售num件物品，若库存不足则会购入足够的物品
		if(sto.stock<num){    
			pur.buy(num-sto.stock, sto);
		}
		sto.stock -= num;
		System.out.println("销售了："+num);
	}
}

//库存类
class Stock {
	int stock;//库存量
	
	public void setStock(int num){
		this.stock = num;
	}
	
	public int getStock(){
		return stock;
	}
	
	void check(Purchase pur,Stock sto){    //检测库存，若库存不足则购入知道库存为5
		if(stock<=0){
			System.out.println("库存要不足了:"+stock);
			pur.buy(5-stock, sto);
		}
		else{
			System.out.println("库存还有："+stock);
		}
	}
}

    没有使用中介者模式，则三个类中都存在相互作用，每个类中的方法都会调用另外的类，他们之间的耦合程度非常高。

2）使用中介者模式（这个示例没有把同时类抽象）

//抽象中介者类
public abstract class AbstractMediator {
	Purchase pur;
	Sell sell;
	Stock stock;
	
	public AbstractMediator(Purchase pur,Sell sell,Stock stock){    //用于子类构造函数
		this.pur = pur;
		this.sell = sell;
		this.stock = stock;
	}
	
	abstract void buy(int num);
	abstract void sell(int num);
	abstract void check();
}

//具体中介者类
public class Mediator extends AbstractMediator {

	Mediator(Purchase pur,Sell sell,Stock sto){    //调用父类构造函数
		super(pur,sell,sto);
	}
	void buy(int num){    //实现购买方法
		stock.stock += num;
		System.out.println("买入了："+num);
	}
	
	void sell(int num){    //实现销售方法
		if(stock.stock<num){
			buy(num-stock.stock);
		}
		stock.stock -= num;
		System.out.println("销售了："+num);
	}
	
	void check(){        //实现检测库存方法
		if(stock.stock<=0){
			System.out.println("库存要不足了:"+stock.stock);
			buy(5-stock.stock);
		}
		else{
			System.out.println("库存还有："+stock.stock);
		}
	}
}

//购买类
public class Purchase {
	void buy(int num,AbstractMediator med){    //把买物品的消息通知给中介者，让中介者完成
		med.buy(num);
	}
}

//销售类
public class Sell {
	void sell(int num,AbstractMediator med){
		med.sell(num);
	}
}

//库存类
public class Stock {
	int stock;
	
	public void setStock(int num){
		this.stock = num;
	}
	
	public int getStock(){
		return stock;
	}
	
	void check(AbstractMediator med){
		med.check();
	}
}

    优点：简化了对象之间的关系，将系统的各个对象之间的相互关系进行封装，使用中介者实现了各个类之间的间接联系 ，降低了他们之间的耦合程度

    缺点：中介者所需要承担的指责过多，他会变得非常复杂，一旦出现问题将会对系统有很大影响，修改也会很困难。