依據這個設計出例如以下

類圖

分析類圖:三個子模塊繼承AbstractColleague，Mediator繼承AbstractMediator，其父類有三個子模塊的實例。另一個統一處理的execute方法()。完畢特定的任務。須要三個子模塊中獨立的方法。

public abstract class AbstractColleague {
 
 protected AbstractMediator mediator; //為何是protected:僅僅對子類公開
 
 public AbstractColleague(AbstractMediator mediator){
  this.mediator=mediator;
 }
}

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 Purchase extends AbstractColleague {
 public Purchase(AbstractMediator mediator) {
  super(mediator);
 }
 
 public void buyIBMcomputer(int number){
  super.mediator.execute("purchase.buy",number);
 }
 public void refuseBuyIBM(){
  System.out.println("不再採購IBM電腦");
 }
}

public class Sale extends AbstractColleague {
 public Sale(AbstractMediator mediator) {
  super(mediator);
 }
 
 public void sellIBMComputer(int number){
  super.mediator.execute("sale.sell",number);
  System.out.println("銷售電腦:"+number+"臺");
 }
 
 //反饋，0~100變化
 public int getSaleStatus(){
  Random rand=new Random(System.currentTimeMillis());
  int saleStatus=rand.nextInt(100);
  System.out.println("IBM電腦的銷售情況為:"+saleStatus);
  return saleStatus;
 }
 public void offSale(){
  super.mediator.execute("sale.offsell");
 }
}

public class Stock extends AbstractColleague {
 public Stock(AbstractMediator mediator) {
  super(mediator);
 }
 
 private static int COMPUTER_NUMBER=100;
 
 public void increase(int number){
  COMPUTER_NUMBER+=number;
  System.out.println("庫存數量:"+COMPUTER_NUMBER);
 }
 public void decrease(int number){
  COMPUTER_NUMBER-=number;
  System.out.println("庫存數量:"+COMPUTER_NUMBER);
 }
 public int getStockNumber(){
  return COMPUTER_NUMBER;
 }
 public void clearStock(){
  System.out.println("清理存貨數量:"+COMPUTER_NUMBER);
  super.mediator.execute("stock.clear");
 }
}

public class Mediator extends AbstractMediator {
 @Override
 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)objects[0]);
  }else if(str.equals("sale.offsell")){  //折價銷售
   this.offSell();
  }else if(str.equals("stock.clear")){  //清倉處理
   this.clearStock();
  }
 }
 private void buyComputer(Integer number) {
  int saleStatus=super.sale.getSaleStatus();
  if(saleStatus>80){	 //銷售狀態好
   System.out.println("採購IBM電腦:"+number+"臺");
   super.stock.increase(number);
  }else{	 //銷售狀態不好
   int buyNumber=number/2;
   System.out.println("採購IBM電腦:"+buyNumber+"臺");
  }
 }
 private void sellComputer(Integer number) {
  if(super.stock.getStockNumber()<number){ //庫存不足不夠銷售
   super.purchase.buyIBMcomputer(number);
  }
  super.stock.decrease(number);
 }
 //折價銷售
 private void offSell() {
  System.out.println("折價銷售IBM電腦"+stock.getStockNumber()+"臺");
 }
 //清倉處理
 private void clearStock() {
  super.sale.offSale();
  super.purchase.refuseBuyIBM();
 }
}

public static void main(String[] args) {
  AbstractMediator mediator=new Mediator();   //一個中介者
  System.out.println("------------採購人員採購電腦--------------");
  Purchase purchase=new Purchase(mediator);  //查看其抽象類的構造方法就知道
  purchase.buyIBMcomputer(100);
  System.out.println("-------------銷售人員銷售電腦-------------");
  Sale sale=new Sale(mediator);
  sale.sellIBMComputer(1);
  System.out.println("------------庫房管理人員清庫處理--------------");
  Stock stock=new Stock(mediator);
  stock.clearStock();
 }

說明

通用寫法

public abstract class Mediator {
//定義同事類
protected ConcreteColleague1 c1;
protected ConcreteColleague2 c2;
//通過getter/setter方法把同事類註入進來
public ConcreteColleague1 getC1() {
return c1;
}
public void setC1(ConcreteColleague1 c1) {
this.c1 = c1;
}
public ConcreteColleague2 getC2() {
return c2;
}
public void setC2(ConcreteColleague2 c2) {
this.c2 = c2;
}
//中介者模式的業務邏輯
public abstract void doSomething1();
public abstract void doSomething2();
}

public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator _mediator){
this.mediator = _mediator;
}
}

public class ConcreteMediator extends Mediator {
@Override
public void doSomething1() {
//調用同事類的方法，僅僅要是public方法都能夠調用
super.c1.selfMethod1();
super.c2.selfMethod2();
}
public void doSomething2() {
super.c1.selfMethod1();
super.c2.selfMethod2();
}
}

public class ConcreteColleague1 extends Colleague {
//通過構造函數傳遞中介者
public ConcreteColleague1(Mediator _mediator){
super(_mediator);
}
//自有方法 self-method
public void selfMethod1(){
//處理自己的業務邏輯
}
//依賴方法 dep-method
public void depMethod1(){
//處理自己的業務邏輯
//自己不能處理的業務邏輯，托付給中介者處理
super.mediator.doSomething1();
}
}

長處

我是菜鳥，我在路上。

設計模式_中介者模式