设计模式-行为型模式-中介者模式

public class Purchase {
	// 采购IBM电脑
	public void buyIBMcomputer(int number){
		// 访问库存
		Stock stock = new STock();
		// 访问销售
		Sale sale = new Sale();
		// 电脑销售情况
		int saleStatus = sale.getSaleStatus();
		// 对销售进行判断
		if(saleStatus > 80){	// 销售情况良好
			System.out.println("采购IBM电脑" + number + "台");
			// 往库存里放入产品
			stock.increase(number);
		}else {
			int buyNumber = number / 2;	// 折半销售
			System.out.println("采购IBM电脑" + number + "台");
		}
	}
	// 不再采购IBM电脑
	public void refuseBuyIBM(){
		System.out.println("不再采购IBM电脑");
	}
}

public class Stock{
	// 初始化
	private static int COMPUTER_NUMBER = 100;
	// 库存增加
	public void increase(int number){
		COMPUTER_NUMBER = COMPUTER_NUMBER + number;
	}
	// 库存降低
	public void decrease(int number){
		COMPUTER_NUMBER = COMPUTER_NUMBER - number;
	}
	// 获得库存数量
	public int getStockNumber(){
		return COMPUTER_NUMBER;
	}
	// 通知销售进行销售
	public void clearStock(){
		Purchase purchase = new Purchase();
		Sale sale = new Sale();
		sale.offSale();	// 折半销售
		purchase.refuseBuyIBM();	// 要求不再采购
	}
}

public class Sale{
	// 销售
	public void sellIBMComputer(int number){
		// 访问库存
		Stock stock = new Stock();
		// 访问采购
		Purchase purchase = new Purchase();
		if(stock.getStockNumber() < number){	// 如果库存数量不足，进行购买
			purchase.buyIBMcomputer(number);
		}
		stock.decrase(number);	// 销售完成以后，清理库存
	}
	// 反馈销售情况,根据销售判断是否折半
	public int getSaleStatus(){
		Random rand = new Random(System.currentTimeMillis());
		int saleStatus = rand.nextint(100);
		return saleStatus;
	}
	// 进行折半销售
	public void offSale(){
		Stock stock = new Stock();
	}
	
}

public class Client{
	public static void main(String[] args){
		// 采购人员采购电脑
		Purchase purchase = new Purchase();
		purchase.buyIBMcomputer(100);
		// 销售电脑
		Sale sale = new Sale();
		sale.selllBMComputer(1);
		// 库房管理人员管理库存
		Stock stock = new Stock();
		stock.clearStock();
	}
}

// 抽象中介者
public abstract class AbstractMediator{
	protected Purchase purchase;
	protected Sale sale;
	protected Stock stock;
	// 构造函数
	public AbstractMediator(){
		purchase = new Purchase(this);
		sale = new Sale(this);
		stock = new Stock(this);
	}
	// 事件方法，处理多个对象之间的关系
	public abstract void execute(String str, Object...objects);
}

// 产生中介者
public class Mediator extends AbstractMediator{
	public void execute(String str, Object...objects){
		if(str.equals("purchase.buy")){	// 如果需要采购电脑
			this.buyComputer((Integer)objects[0]);	// 通知采购
		}else if(str.equals("sale sell")){	// 销售电脑
			this.sellComputer((Integer)object[0]);
		}else if(str.equals("sale offsell")){	// 折半销售
			this.offSell();
		}else if(str.equals("stock clear")){	// 清仓处理
			this.clearStock();
		}
	}
	private void buyComputer(int number){
		int saleStatus = super.sale.getSaleStatus();
		if(saleStatus > 80){	// 如果销售良好
			super.stock.increase(number);
		}else{
			int buyNumber = number / 2;
		}
	}
	private void sellComputer(int number){
		if(super.stock.getStockNumber() < number){ // 库存不够销售的时候
			super.purchase.buyIBMcomputer(number);
		}
		super.stock.decrease(number);
	}
	// 折半销售电脑
	private void offSell(){
		
	}
	// 清仓处理
	private void clearStock(){
		// 要求清仓销售
		super.sale.offSale();
		// 要求采购人员不要采购
		super.purchase.refuseBuyIBM();
	}
}

public abstract class AbstractColleague{
	protected AbstractMediator mediator;
	public AbstractColleagur(AbstractMediator _mediator){
		this.mediator = _mediator;
	}
}

public class Purchase extends AbstractColleague{
	public Purchase(AbstractMediator _mediator){	// 和中介建立联系
		super(_mediator);
	}
	// 采购电脑
	public void buyIBMcomputer(int number){
		super.meidator.execute("purchase.buy", number);
	}
	// 不在采购电脑
	public void refuseBuyIBM(){
		
	}
}

public class Stock extends AbstractColleague{
	public Stock(ABstractMediator _mediator){
		super(_meidator);
	}
	// 刚刚开始电脑
	private static int COMPUTER_NUMBER = 100;
	// 库存通知
	public void increase(int number){
		COMPUTER_NUMBER = COMPUTER_NUMBRT + number;
	}
	// 库存降低
	public void decrease(int number){
		COMPUTER_NUMBER = COMPUTER_NUMBER - number;
	}
	// 获得库存数量
	public int getStockNumber(){
		return COMPUTER_NUMBER;
	}
	// 存货量多，不采购，进行销售
	public void clearStock(){
		super.mediator.execute("stock.clear");
	}
}

public class Client{
	public static void main(String[] args){
		AbstractMediator mediator = new Mediator();
		Purchase purchase = new Purchase(mediator);	// 传入具体的场景
		purchase.buyIBMcomputer(100);
		Sale sale = new Sale(mediator);
		sale.sellIBMComputer(1);
		Stock stock = new Stock(mediator);
		stock.clearStock();
	}
}