2. 程式人生 > >《Head First 設計模式》筆記9

《Head First 設計模式》筆記9

阿新 • • 發佈：2018-12-31

狀態模式（State）

允許物件在內部狀態改變時改變它的行為，物件看起來好像修改了它的類。

栗子

現在有一臺糖果機，它的狀態（挺複雜的）：
- 沒有 25 分錢 -> 投入 25 分錢 -> 有 25 分錢
- 有 25 分錢 -> 轉動曲柄 -> 售出糖果（數量不為0） | 糖果售罄（數量為0）
- 有 25 分錢 -> 退錢按鈕 -> 退出 25 分錢
- 售出糖果 -> 沒有 25 分錢

從上面的狀態實現程式碼的步驟：
1. 找出所有狀態 -> 共四種：沒有 25 分錢、有 25 分錢、售出糖果、糖果售罄。
2. 建立一個持有當前狀態的例項變數 state。
3. 寫出所有可能發生的動作判斷。

class GumballMachine {
    private final static int SOLD_OUT = 0;
    private final static int NO_QUARTER = 1;
    private final static int HAS_QUARTER = 2;
    private final static int SOLD = 3;

    private int state = SOLD_OUT; // 當前狀態
    private int count = 0; // 糖果數目

    public GumballMachine(int
 
 count) {
        this.count = count;
        // 初始糖果機的糖果數
        if (count > 0) {
            // 大於0表示等待別人投幣
            state = NO_QUARTER;
        }
    }

    // 投進25分錢
    public void insertQuarter() {
        if (state == HAS_QUARTER) {
            System.out.println("你已經投過25分錢了，請不要重複投幣");
        } else
 
 if (state == NO_QUARTER) {
            System.out.println("投進25分錢");
            state = HAS_QUARTER;
        } else if (state == SOLD_OUT) {
            System.out.println("沒有糖果了，不要投幣");
        } else if (state == SOLD) {
            System.out.println("請稍等，正在出糖果");
        }
    }

    // 客戶嘗試退錢
    public void ejectQuarter() {
        if (state == HAS_QUARTER) {
            System.out.println("已退還25分錢");
            state = NO_QUARTER;
        } else if (state == NO_QUARTER) {
            System.out.println("你還沒投幣呢");
        } else if (state == SOLD_OUT) {
            System.out.println("沒有糖果時無法投幣，不要騙錢");
        } else if (state == SOLD) {
            System.out.println("你已經轉動曲柄了，無法退錢");
        }
    }

    // 客戶轉動曲柄
    public void turnCrank() {
        if (state == HAS_QUARTER) {
            System.out.println("你轉動了曲柄");
            state = SOLD;
            dispense();
        } else if (state == NO_QUARTER) {
            System.out.println("你還沒投幣呢");
        } else if (state == SOLD_OUT) {
            System.out.println("已經沒有糖果了");
        } else if (state == SOLD) {
            System.out.println("轉幾次都只能拿一次");
        }
    }

    // 糖果機發糖果
    public void dispense() {
        if (state == SOLD) {
            System.out.println("糖果已發出");
            count--;
            if (count == 0) {
                System.out.println("已經沒有糖果嘍");
                state = SOLD_OUT;
            } else {
                state = NO_QUARTER;
            }
        } else if (state == NO_QUARTER) {
            System.out.println("你還沒投幣呢");
        } else if (state == SOLD_OUT) {
            System.out.println("沒有糖果發");
        } else if (state == SOLD) {
            System.out.println("沒有糖果發");
        }
    }
}

多麼縝密的判斷，基本上沒什麼漏洞了。

新需求

現在產品經理提需求來了：當曲柄被轉動時，有 10% 的機率掉出兩個糖果。

看回上面縝密的程式碼，是不是有點無從入手？這個需求真是要了命了……如果需求再有變更，上面的程式碼基本上就得推倒重來了，因為程式碼邏輯判斷太複雜。

滿足需求

我們可以把這四個狀態當作一個實體，比如糖果機當前處在沒投幣的狀態，那麼在該狀態下，可以通過投幣動作使糖果機轉移到投了幣狀態，其他狀態也是這樣，基本上可以把 if else 這些判斷語句分離出來。

定義狀態介面：

interface State {
    void insertQuarter();

    void ejectQuarter();

    void turnCrank();

    void dispense();
}

然後每種狀態都實現該介面（先看總體）：

class SoldState implements State

class SoldOutState implements State

class NoQuarterState implements State

class HasQuarterState implements State

// 新需求中的“中獎狀態”
class WinnerState implements State

還有新的糖果機（還沒新增中獎狀態）：

class GumballMachine {
    private State soldState;
    private State soldOutState;
    private State noQuarterState;
    private State hasQuarterState;

    private State state = soldState;
    private int count = 0;

    public GumballMachine(int count) {
        soldState = new SoldState(this);
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        this.count = count;
        if (count > 0) {
            state = noQuarterState;
        }
    }

    public void insertQuarter() {
        state.insertQuarter();
    }

    public void ejectQuarter() {
        state.ejectQuarter();
    }

    // 轉動曲柄後
    // 具體是否能發出糖果就需要當前狀態是 hasQuarterState
    public void turnCrank() {
        state.turnCrank();
        state.dispense();
    }

    public void setState(State state) {
        this.state = state;
    }

    // 不再通過 dispense 發放糖果
    public void releaseBall() {
        System.out.println("糖果已發出");
        if (count != 0) {
            count--;
        }
    }

    // getter
    public State getState() {
        return state;
    }

    public int getCount() {
        return count;
    }

    public State getSoldState() {
        return soldState;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }
}

分別實現的狀態類

沒投幣的狀態：

class NoQuarterState implements State {
    private GumballMachine gumballMachine;

    public NoQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("投進25分錢");
        gumballMachine.setState(gumballMachine.getHasQuarterState());
    }

    @Override
    public void ejectQuarter() {
        System.out.println("你還沒投幣呢，怎麼退錢");
    }

    @Override
    public void turnCrank() {
        System.out.println("你轉動了曲柄，但你還沒投幣呢");
    }

    @Override
    public void dispense() {
        System.out.println("你要先投幣");
    }
}

投了幣的狀態：

class HasQuarterState implements State {
    private GumballMachine gumballMachine;

    public HasQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("你已經投過25分錢了，請不要重複投幣");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("已退還25分錢");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    @Override
    public void turnCrank() {
        System.out.println("你轉動了曲柄");
        gumballMachine.setState(gumballMachine.getSoldState());
    }

    @Override
    public void dispense() {
        System.out.println("沒有糖果發");
    }
}

售出糖果的狀態：

class SoldState implements State {
    private GumballMachine gumballMachine;

    public SoldState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("請稍等，正在出糖果");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("你已經轉動曲柄了，無法退錢");
    }

    @Override
    public void turnCrank() {
        System.out.println("轉幾次都只能拿一次");
    }

    @Override
    public void dispense() {
        gumballMachine.releaseBall();
        if (gumballMachine.getCount() > 0) {
            gumballMachine.setState(gumballMachine.getNoQuarterState());
        } else {
            System.out.println("已經沒有糖果嘍");
            gumballMachine.setState(gumballMachine.getSoldOutState());
        }
    }
}

糖果售罄的狀態：

class SoldOutState implements State {
    private GumballMachine gumballMachine;

    public SoldOutState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("沒有糖果了，不要投幣");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("沒有糖果時無法投幣，不要騙錢");
    }

    @Override
    public void turnCrank() {
        System.out.println("你轉動了曲柄，但是已經沒有糖果了");
    }

    @Override
    public void dispense() {
        System.out.println("沒有糖果發");
    }
}

新需求中的中獎狀態：

class WinnerState implements State {
    private GumballMachine gumballMachine;

    public WinnerState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("請稍等，正在出糖果");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("你已經轉動曲柄了，無法退錢");
    }

    @Override
    public void turnCrank() {
        System.out.println("轉幾次都只能拿一次");
    }

    // 除了發糖外，其他資訊和售出糖果的狀態一樣
    @Override
    public void dispense() {
        System.out.println("恭喜！你拿到了兩顆糖");
        // 第一顆糖
        gumballMachine.releaseBall();
        if (gumballMachine.getCount() == 0) {
            gumballMachine.setState(gumballMachine.getSoldOutState());
        } else {
            // 第二顆糖
            gumballMachine.releaseBall();
            if (gumballMachine.getCount() > 0) {
                gumballMachine.setState(gumballMachine.getNoQuarterState());
            } else {
                System.out.println("已經沒有糖果嘍");
                gumballMachine.setState(gumballMachine.getSoldOutState());
            }
        }
    }
}

需求還沒解決完

上面的程式碼只是解決了狀態的問題，但還沒有完全滿足需求，10% 的隨機中獎還沒寫。（其實也沒什麼難度了）

給糖果機加上中獎狀態：

class GumballMachine {
    // ...
    private State winnerState;

    public GumballMachine(String location, int count) {
        winnerState = new WinnerState(this);
        // ...
    }

    public State getWinnerState() {
        return winnerState;
    }

    // ...
}

因為只有在投了幣的情況下才能轉動曲柄 -> 發糖 | 中獎，所以要在投了幣的狀態加入這 10% 隨機：

class HasQuarterState implements State {
    // ...

    @Override
    public void turnCrank() {
        System.out.println("你轉動了曲柄");
        Random randomWinner = new Random(System.currentTimeMillis());
        // 中獎
        // 10次裡面有一次是0，即 1/10
        int winner = randomWinner.nextInt(10);
        if (winner == 0 && gumballMachine.getCount() > 1) {
            gumballMachine.setState(gumballMachine.getWinnerState());
        } else {
            gumballMachine.setState(gumballMachine.getSoldState());
        }
    }

    // ...

相關推薦

Head First設計模式筆記

一、設計原則 1、找到應用中可能需要變化之處，把它們獨立出來，不要和不需要變化的程式碼混在一起 把會變化的部分取出並“封裝”起來，好讓其他部分不會受到影響。 2、針對介面程式設計，而不是針對實現程式設計 3、多用組合，少用繼承 4、為了互動物件之間的鬆耦合設計而

《Head First 設計模式》筆記9

狀態模式（State） 允許物件在內部狀態改變時改變它的行為，物件看起來好像修改了它的類。 栗子 現在有一臺糖果機，它的狀態（挺複雜的）： - 沒有 25 分錢 -> 投入 25 分錢 -> 有 25 分錢 - 有 25 分錢 ->

《Head First 設計模式》學習筆記——復合模式

listener 解讀 out 部件 register != file 窗體 event 模型-視圖-控制器（MVC模式）是一種很經典的軟件架構模式。在UI框架和UI設計思路中扮演著很重要的角色。從設計模式的角度來看，MVC模式是一種復合模式。它將多個設計模式在

《Head first設計模式》學習筆記 – 叠代器模式

sys sorry 微軟雅黑 封裝 system ready 3.5 消息 all 《Head first設計模式》學習筆記 – 叠代器模式 代器模式提供一種方法順序訪問一個聚合對象中的各個元素，而又不暴露其內部的表示。 爆炸性新聞：對象村餐廳和對象村煎餅屋合並了！真是

Head First設計模式讀書筆記八 第九章下 組合模式

組合模式+迭代器模式 接著上一節最後的例子，例子的最終list結構圖是這樣的： 若要給DinerMenu新加一種Menu（即下面這樣），則需要對現有結構進行較大改動。 可以看到，目前的結構中分為兩種結構，一種是menu，是一種容器，可以包含選單項，而第二種

Head First設計模式讀書筆記九 第十章 狀態模式

狀態模式例項 用Java設計糖果機吧 大致流程： 上圖中，有四種狀態：沒有硬幣，有硬幣，準備售出狀態以及糖果售罄狀態。而控制糖果機狀態轉換的則是各種動作（Action），這些動作分別是投入硬幣，超時判斷，轉動曲柄，判斷糖果決定是否售出。 GumballMac

Head First 設計模式讀書筆記——策略模式

最近研究了一些優秀的開源框架，學習了很多開源框架中自己不熟悉的知識，發現一些優秀的開源框架都或多或少的使用了設計模式，正好為了能分析原始碼不那麼頭疼乾脆先複習一下以前只看過的設計模式，於是我翻出了壓箱底的head first 設計模式，這本書圖文並茂，就是廢話很多不過它完全順

《Head First 設計模式》筆記10

代理模式（Proxy） 為另一個物件提供一個替身或佔位符以控制對這個物件的訪問。 栗子 還記得上一個筆記中的糖果機吧，現在產品經理想要一份寫著糖果機位置、庫存和當前的狀態報告。 是不是挺簡單的？趕緊寫程式碼。 糖果機加上位置資訊： class

Head First設計模式讀書筆記

    設計原則：找出應用中可能需要變化之處，把它們獨立出來，不要和那些不需要變化的程式碼混在一起。針對介面程式設計，而不是針對實現程式設計。多用組合，少用繼承。 為了互動物件之間的鬆耦合設計而努力。類應該對拓展開放，對修改關閉。依賴倒置原則：要依賴抽象，不要依賴具體類。不能

Head First設計模式學習筆記-------（12）狀態模式

我們今天開門見山吧，我們又接到了一個新的專案，讓我們看看這次的專案是什麼吧 對於大家學了熟練的開發技巧，看到這麼一個專案，是不是內心第一個想法就是------真TM簡單。 public class GumballMachine { final static int

《Head.First設計模式》的學習筆記（11）－－模板方法模式

意圖：在一個方法中定義一個演算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以在不改變演算法結構的情況下，重新定義演算法中的某些步驟。 結構：   其中AbstractClass 實現為: public abstract class AbstractClass {

《Head First 設計模式》筆記2

觀察者模式（Observer） 定義了物件之間的一對多依賴，當一個物件改變狀態時，它的所有依賴者都會收到通知並自動更新。 初識 我們先來了解一下報紙和雜誌的訂閱是怎麼回事： 1. 報社的業務就是出版報紙、雜誌等各種出版物。 2. 如果我想看報社的

《Head first設計模式》學習筆記

抽象工廠模式提供一個介面，用於建立相關或依賴物件的家族，而不需要明確指定具體類。 確保原料的一致 披薩店成功的關鍵在於新鮮、高質量的原料。要如何確保每家加盟店使用高質量的原料？你打算建造一家生成原料的工廠，並將原料運送到各家加盟店。對於這個做法，現在還剩下一個問題：加

Head First 設計模式讀書筆記

public class DuckTest {     public static void main(String[] args) {         MallardDuck duck = new MallardDuck();         duck.setFlyBehavior(new FlyWithW

《Head.First設計模式》的學習筆記（15）－－代理模式

 意圖： 為另一個物件提供一個替身或佔位符得以訪問這個物件。 結構： 接著我們來看RMI遠端代理： 1.我們先在伺服器註冊好幾個糖果機，由於我們現在使用RMI，我們需要構造糖果機和狀態。 糖果機首先變成一個服務，我們為糖果機建立一個遠端介面，讓開介面提供了一組可以遠端

Head First 設計模式 讀書筆記

1、 使用模式最好的方式：把模式裝進腦子中，然後在你的設計中和已有的應用中，尋找何處可以使用這些模式。2、 對程式碼所做的區域性修改，影響層面不只是區域性（會飛的橡皮鴨子）。3、 當涉及“維護”時，為了“複用”目的而使用繼承，結局並不完美。4、 不變的是變化。5、 設計原則一

《Head First 設計模式》筆記

第一章 策略模式 00設計原則：找出應用中可能需要變化之處，把它們獨立出來，不要和那些不需要變化的程式碼放在一起。 把會變化的部分取出並封裝起來，好讓其它部分不會受到影響。結果如何？程式碼變化引起的不經意後果變少，系統變得更有彈性。 00設計原則：針對介面程式設計，而不是針對實現程式設計。 “針對介面程式設計

Head First設計模式之模板方法模式

names 去除 缺點 ide 個數 write ima 父類 public 一、定義 在一個方法中定義一個算法的骨架，而將一些步驟延遲到子類中，使得子類可以不改變算法結構的情況下，重定義該算法中的某些特定步驟。 比較通俗的說法，子類決定如何實現算法中的某些步驟，比如兩

Head First設計模式之外觀模式

實現 add ads important pac mar private 入口 summary 一、定義 外觀模式提供了一個統一的接口，用來訪問子系統中的一群接口。外觀定義了一個高層接口，讓子系統更容易使用。 外觀模式不只是簡化了接口，也將客戶從組件的子系統中解耦。

Head First設計模式之代理模式

collect prot indent margin 虛擬代理 ans sig smart ati 一、定義 定義：為其他對象提供一種代理以控制對這個對象的訪問 在代理模式中，我們創建具有現有對象的對象，以便向外界提供功能接口。 二、結構 代理模式一般會有三個角