設計模式-行為型模式-中介者模式

行為型模式

劃分類和物件的職責。

中介者模式

進銷存管理，即採購，銷售，庫存。

其中類圖

程式碼如下

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電腦");
    }
}
 

該Purchase定義了採購電腦的標準。根據電腦的銷售情況，往庫存裡放入產品。如果銷售不好，則折半銷售。
另外定義了一個不再採購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();
    }
}

應用

MVC，閘道器，一個購物車栗子，需求為選擇顏色，並輸入購買數量，要求和從後臺獲取到的庫存進行對比，在頁面顯示。思路，為三方，庫存資料，輸入資料，顯示結果，引入中介者，在中介者內部進行資料的判斷，並將結果輸出，如果此時需要增加新的選項，直接在中介者內部書寫業務程式碼即可。

總結

有中介者和同事類，中介者通過get和set方法將同事傳入，然後進行資料的交換，中介完成任務，然後同事類，通過構造方法將中介傳入，然後和中介進行交流，獲取資訊。
中介，get，set傳入同事，進行資料處理，交換。
同事，通過構造傳入，進行和中介通訊。