簡說設計模式——狀態模式

一、什麼是狀態模式

　　狀態這個詞彙我們並不陌生，在日常生活中，不同時間就有不同的狀態，早上起來精神飽滿，中文想睡覺，下午又漸漸恢復，晚上可能精神更旺也可能耗費體力只想睡覺，這一天中就對應著不同的狀態。或者對軟體開發人員更形象的描述可能是UML的狀態圖（即用於描述一個實體基於事件反應的動態行為，顯示了該實體如何根據當前所處的狀態對不同的事件做出反應）。

　　其實相對來說，就是一種狀態的變化，而狀態模式主要解決的問題就是當控制一個物件狀態轉換的條件表示式過於複雜時的情況。即把狀態的判斷邏輯轉移到標識不同狀態的一系列類當中。

　　狀態模式（State），當一個物件的內在狀態改變時允許改變其行為，這個物件看起來像是改變了其類。UML結構圖如下：

　　其中，Context類為環境角色，用於維護一個ConcreteState子類的例項，這個例項定義當前的狀態；State為抽象狀態角色，定義一個介面以封裝與Context的一個特定介面狀態相關的行為；ConcreteState是具體狀態角色，每一個子類實現一個與Context的一個狀態相關的行為。

　　1. Context類

　　環境角色具有兩個職責，即處理本狀態必須完成的任務，及決定是否可以過渡到其它狀態。對於環境角色，有幾個不成文的約束：

• 即把狀態物件宣告為靜態常量，有幾個狀態物件就宣告幾個狀態常量
• 環境角色具有狀態抽象角色定義的所有行為，具體執行使用委託方式

public class Context {

    //定義狀態
    public final static State STATE1 = new ConcreteState1();
    public final static State STATE2 = new ConcreteState2();
    
    //當前狀態
    private State currentState;
    
    //獲得當前狀態
    public State getCurrentState() {
        return currentState;
    }

    //設定當前狀態
    public void setCurrentState(State currentState) {
        this.currentState = currentState;
//        System.out.println("當前狀態：" + currentState);
        //切換狀態
        this.currentState.setContext(this);
    }
    
    public void handle1() {
        this.currentState.handle1();
    }
    public void handle2() {
        this.currentState.handle2();
    }
    
}

　　2. State抽象狀態類

　　抽象環境中宣告一個環境角色，提供各個狀態類自行訪問，並且提供所有狀態的抽象行為，由各個實現類實現。

public abstract class State {
    
    protected Context context;
    public void setContext(Context context) {
        this.context = context;
    }

    //行為1
    public abstract void handle1();
    //行為2
    public abstract void handle2();
    
}

　　3. 具體狀態

　　具體狀態實現，這裡以定義ConcreteState1和ConcreteState2兩個具體狀態類為例，ConcreteState2的具體內容同ConcreteState1。

public class ConcreteState1 extends State {

    @Override
    public void handle1() {
        //...
        System.out.println("ConcreteState1 的 handle1 方法");
    }

    @Override
    public void handle2() {
        super.context.setCurrentState(Context.STATE2);
        System.out.println("ConcreteState1 的 handle2 方法");
    }
    
}

　　4. Client客戶端

　　定義Context環境角色，初始化具體狀態1，執行行為觀察結果。

public class Client {

    public static void main(String[] args) {
        //定義環境角色
        Context context = new Context();
        //初始化狀態
        context.setCurrentState(new ConcreteState1());
        //行為執行
        context.handle1();
        context.handle2();
    }
    
}

 　　執行結果如下：

　　

　　從執行結果可見，我們已經隱藏了狀態的變化過程，它的切換引起了行為的變化。對外來說，我們只看到了行為的改變，而不用知道是狀態變化引起的。

　　如果還是有點不理解的話，參考一下下方第三部分的內容，狀態模式的具體例項即可。

二、狀態模式的應用

　　1. 何時使用

• 程式碼中包含大量與物件狀態有關的條件語句

 　　2. 方法

• 將各種具體的狀態類抽象出來

　　3. 優點

• 結構清晰，避免了過多的switch…case或if…else語句的使用
• 很好的體現了開閉原則和單一職責原則，想要增加狀態就增加子類，想要修改狀態就修改子類即可
• 封裝性非常好，狀態變化放置到了類的內部來實現，外部呼叫不需要知道類內部如何實現狀態和行為的變換

　　4. 缺點

• 子類會太多，也即類膨脹

　　5. 使用場景

• 行為隨狀態改變而改變的場景
• 條件、分支判斷語句的替代者

　　6. 應用例項

• 電梯，有執行狀態、開門狀態、閉門狀態、停止狀態等
• 一日從早到晚自身的狀態，比如工作狀態、學習狀態等等
• 運動員可以有正常狀態、非正常狀態和超長狀態

　　7. 注意事項

• 在行為受狀態約束的情況下可以使用狀態模式，使用時物件的狀態最好不要超過5個

三、狀態模式的實現

　　我們經常坐電梯都知道，電梯有多種狀態，就按最簡單的來說，包括執行狀態、停止狀態、開門狀態、閉門狀態。下面就以電梯執行為例，舉一個具體的例項，UML圖如下：

　　1. 環境角色Context

　　首先定義出電梯的所有狀態，然後定義當前電梯狀態，再定義四種狀態對應的方法，如Openning狀態是由open()方法產生的。至於這些方法中的邏輯，就用print來代替了。

public class Context {
    
    //定義出電梯的所有狀態
    public final static LiftState OPENNING_STATE = new OpenningState();
    public final static LiftState CLOSING_STATE = new ClosingState();
    public final static LiftState RUNNING_STATE = new RunningState();
    public final static LiftState STOPPING_STATE = new StoppingState();
    
    //定義一個當前電梯狀態
    private LiftState liftState;

    public LiftState getLiftState() {
        return liftState;
    }

    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        //通知到各個實現類中
        this.liftState.setContext(this);
    }
    
    public void open() {
        this.liftState.open();
    }
    
    public void close() {
        this.liftState.close();
    }
    
    public void run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }
}

　　2. 抽象電梯狀態LiftState

　　這裡我們定義並把Context這個環境角色聚合進來，並傳遞到子類。所以我們可以這樣理解，Context環境角色的作用就是串聯各個狀態的過渡，也就是在4個具體的實現類中，各自根據自己的環境來決定如何進行狀態的過渡。

public abstract class LiftState {

    protected Context context;
    
    public void setContext(Context context) {
        this.context = context;
    }
    
    //電梯門開啟動作
    public abstract void open();
    //電梯門關閉動作
    public abstract void close();
    //電梯執行
    public abstract void run();
    //電梯停止
    public abstract void stop();
    
}

　　3. 電梯開門狀態

　　對於開門狀態，除去自身的開啟電梯門的方法之外，在開啟門之後應該還具備關閉電梯門的功能，而門開著的時候是不能執行也不能停止的。

public class OpenningState extends LiftState {
    
    //執行開啟電梯門方法
    @Override
    public void open() {
        System.out.println("電梯門開啟");
    }

    //開啟後還可以關閉電梯門
    @Override
    public void close() {
        //狀態修改
        super.context.setLiftState(Context.CLOSING_STATE);
        //動作委託為CLOSING_STATE執行
        super.context.getLiftState().close();
    }

    //門開著不能執行
    @Override
    public void run() {
        //什麼都不做
    }

    //門開著已經停止了
    @Override
    public void stop() {
        //什麼都不做
    }

}

　　4. 電梯閉門狀態

　　對於閉門狀態，除去自身外，電梯門關閉之後還可以再度開啟，所以有open()方法；而門關了之後是可以執行的，所以有run()方法；如果關了門沒有按樓層的話，此時電梯處於停止狀態，所以有stop()方法。

public class ClosingState extends LiftState {

    //電梯門關了可以再開
    @Override
    public void open() {
        //置為敞門狀態
        super.context.setLiftState(Context.OPENNING_STATE);
        super.context.getLiftState().open();
    }

    // * 執行電梯門關閉方法
    @Override
    public void close() {
        System.out.println("電梯門關閉");
    }

    //電梯門關了就執行
    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

    //電梯門關了但沒有按樓層
    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }

}

　　5. 電梯執行狀態

　　當電梯處於執行狀態時，此時當然是不能開門的；而門肯定是關了的，所以也不必執行關門方法；此時電梯可以從執行狀態轉變為停止狀態。

public class RunningState extends LiftState {

    //執行時不能開門
    @Override
    public void open() {
        //什麼都不做
    }

    //執行時門肯定是關的
    @Override
    public void close() {
        //什麼都不做
    }

    // * 執行執行方法
    @Override
    public void run() {
        System.out.println("電梯執行中");
    }

    //執行後可以停止
    @Override
    public void stop() {
        //環境設定為停止狀態
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }

}

　　6. 電梯停止狀態

　　當電梯處於停止狀態時，門是關閉著的，所以不能執行關門的方法；但此時是可以開門的；而停止後電梯也可以再度執行，所以存在run()方法。

public class StoppingState extends LiftState {

    //停下了要開門
    @Override
    public void open() {
        super.context.setLiftState(Context.OPENNING_STATE);
        super.context.getLiftState().open();
    }

    //門本來就是關著的
    @Override
    public void close() {
        //什麼都不做
    }

    //停止後可以再執行
    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

    //執行停止方法
    @Override
    public void stop() {
        System.out.println("電梯停止了");
    }

}

　　7. Client客戶端

　　這裡假設初始狀態為閉門狀態，大家可以自行嘗試其它初始值。

public class Client {

    public static void main(String[] args) {
        Context context = new Context();
        
        //定義初始狀態為關門（共四種初始值）
        context.setLiftState(new ClosingState());
        context.open();
        context.close();
        context.run();
        context.stop();
    }
    
}

 　　執行結果如下：

　　

　　如果將setLiftState()方法的引數換成執行狀態，即 context.setLiftState(new RunningState()); ，執行結果如下：

　　

　　可以發現，此時電梯處於執行中，open()方法和close()方法都是無效的。

　　如果不用狀態模式實現的話，常用的方法是在每個方法中使用switch語句來判斷當前狀態進行處理，而使用狀態模式，通過各個子類來實現，避免了switch語句的判斷，使得程式碼看起來不是那麼的冗雜。那麼結合狀態模式的特點，如果現在要增加兩個狀態即通電狀態和斷點狀態呢？其實很簡單，只需增加兩個子類，並在原有類上增加而不是去修改，符合開閉原則；而這裡我們的狀態都是單獨的類，只有與這個狀態有關的因素修改了，這個類才修改，符合迪米特法則。

 

　　原始碼地址：https://gitee.com/adamjiangwh/GoF