我們每天都在乘電梯，那我們來看看電梯有哪些動作（映射到 Java 中就是有多少方法）:開門、關(guān)門、運行、停止，就這四個動作，好，我們就用程序來實現(xiàn)一下電梯的動作，先看類圖設(shè)計：

代碼如下：

/**
 * @description 定義一個電梯的接口
 */
public interface ILift {

    /**
     * 電梯門開啟動作
     */
    void open();

    /**
     * 電梯門關(guān)閉動作
     */
    void close();

    /**
     * 電梯上升或下降
     */
    void run();

    /**
     * 電梯停在某層
     */
    void stop();

}

public class Lift implements ILift {

    @Override
    public void open() {
        System.out.println("電梯門打開...");
    }

    @Override
    public void close() {
        System.out.println("電梯門關(guān)閉...");
    }

    @Override
    public void run() {
        System.out.println("電梯上升或下降...");
    }

    @Override
    public void stop() {
        System.out.println("電梯停在某層...");
    }
}

public class Client {

    public static void main(String[] args) {

        ILift lift = new Lift();
        lift.open();
        lift.close();
        lift.run();
        lift.stop();

    }

}

這個程序有什么問題，你想呀電梯門可以打開，但不是隨時都可以開，是有前提條件的的，你不可能電梯在運行的時候突然開門吧？！電梯也不會出現(xiàn)停止了但是不開門的情況吧？！電梯的這四個動作的執(zhí)行都是有前置條件，具體點說在特定狀態(tài)下才能做特定事，那我們來分析一下電梯有什么那些特定狀態(tài)：

• 門敞狀態(tài)：按了電梯上下按鈕，電梯門開，這中間有5秒的時間，在這個狀態(tài)下電梯只能做的動作是關(guān)門動作，做別的動作那就危險
• 門閉狀態(tài)：電梯門關(guān)閉了，在這個狀態(tài)下，可以進行的動作是：開門（我不想坐電梯了）、停止（忘記按樓層號了）、運行
• 運行狀態(tài)：電梯正在跑，上下竄，在這個狀態(tài)下，電梯只能做的是停止；
• 停止狀態(tài)：電梯停止不動，在這個狀態(tài)下，電梯有兩個可選動作：繼續(xù)運行或者開門；

我們用一張表來表示電梯狀態(tài)和動作之間的關(guān)系：

好，我們來修改一下，先看類圖：

在接口中定義了四個常量，分別表示電梯的四個狀態(tài)：門敞狀態(tài)、關(guān)閉狀態(tài)、運行狀態(tài)、停止狀態(tài)，然后在實現(xiàn)類中電梯的每一次動作發(fā)生都要對狀態(tài)進行判斷，判斷是否運行執(zhí)行，也就是動作的執(zhí)行是否符合業(yè)務(wù)邏輯，實現(xiàn)類中的四個私有方法是僅僅實現(xiàn)電梯的動作，沒有任何的前置條件，因此這四個方法是不能為外部類調(diào)用的，設(shè)置為私有方法。代碼如下：

public interface ILift {

    /**
     * 門敞狀態(tài)
     */
    int OPENING_STATE = 1;

    /**
     * 門閉狀態(tài)
     */
    int CLOSING_STATE = 2;

    /**
     * 運行狀態(tài)
     */
    int RUNNING_STATE = 3;

    /**
     * 設(shè)置電梯的狀態(tài)
     * @param state 電梯狀態(tài)
     */
    void setState(int state);

    /**
     * 停止狀態(tài)
     */
    int STOPPING_STATE = 4;

    /**
     * 電梯門開啟動作
     */
    void open();

    /**
     * 電梯門關(guān)閉動作
     */
    void close();

    /**
     * 電梯上升或下降
     */
    void run();

    /**
     * 電梯停在某層
     */
    void stop();

}

public class Lift implements ILift {

    private int state;

    @Override
    public void setState(int state) {
        this.state = state;
    }

    @Override
    public void open() {
        // 在關(guān)門狀態(tài)和停止狀態(tài)可以開門，其他狀態(tài)什么也不做
        switch (state) {
            case CLOSING_STATE:
            case STOPPING_STATE:
                openWithoutLogic();
                setState(OPENING_STATE);
                break;
            case OPENING_STATE:
            case RUNNING_STATE:
                // do nothing
                break;
            default: // do nothing
        }
    }

    @Override
    public void close() {
        // 只有在開門狀態(tài)可以關(guān)門
        switch (state) {
            case OPENING_STATE:
                closeWithoutLogic();
                setState(CLOSING_STATE);
                break;
            case CLOSING_STATE:
            case STOPPING_STATE:
            case RUNNING_STATE:
                // do nothing
                break;
            default: // do nothing
        }
    }

    @Override
    public void run() {
        // 只有在關(guān)閉狀態(tài)和停止狀態(tài)可以運行
        switch (state) {
            case CLOSING_STATE:
            case STOPPING_STATE:
                runWithoutLogic();
                setState(RUNNING_STATE);
                break;
            case OPENING_STATE:
            case RUNNING_STATE:
                // do nothing
                break;
            default: // do nothing
        }
    }

    @Override
    public void stop() {
        // 只有在關(guān)閉狀態(tài)和運行狀態(tài)可以停止
        switch (state) {
            case CLOSING_STATE:
            case RUNNING_STATE:
                stopWithoutLogic();
                setState(STOPPING_STATE);
                break;
            case OPENING_STATE:
            case STOPPING_STATE:
                // do nothing
                break;
            default: // do nothing
        }
    }

    /**
     * 單純的打開門，不考慮其他條件
     */
    private void openWithoutLogic() {
        System.out.println("電梯門打開...");
    }

    /**
     * 單純的關(guān)閉門，不考慮其他條件
     */
    private void closeWithoutLogic() {
        System.out.println("電梯門關(guān)閉...");
    }

    /**
     * 單純的運行，不考慮其他條件
     */
    private void runWithoutLogic() {
        System.out.println("電梯上升或下降...");
    }

    /**
     * 單純的停止，不考慮其他條件
     */
    private void stopWithoutLogic() {
        System.out.println("電梯停在某層...");
    }

}

public class Client {

    public static void main(String[] args) {

        ILift lift = new Lift();
        // 電梯的初始狀態(tài)為停止狀態(tài)
        lift.setState(ILift.STOPPING_STATE);
        lift.open();
        lift.close();
        lift.run();
        lift.stop();

    }

}

以上的代碼也是有問題的：

• 首先Lift這個類有點長，長的原因是我們在程序中使用了大量的switch…case這樣的判斷（if…else也是一樣），程序中只要你有這樣的判斷就避免不了加長程序，同步的在業(yè)務(wù)比較復雜的情況下，程序體會更長，這個就不是一個很好的習慣了，較長的方法或者
  類的維護性比較差
• 其次，擴展性非常的不好，大家來想想，電梯還有兩個狀態(tài)沒有加，是什么？通電狀態(tài)和斷電狀態(tài)，你要是在程序再增加這兩個方法，你看看open()、close()、run()、stop()這四個方法都要增加判斷條件，也就是說switch斷體中還要增加case項，也就說與開閉原則相違背了；
• 再其次，我們來思考我們的業(yè)務(wù)，電梯在門敞開狀態(tài)下就不能上下跑了嗎？電梯有沒有發(fā)生過只有運行沒有停止狀態(tài)呢（從 40 層直接墜到 1 層嘛）？電梯故障，還有電梯在檢修的時候，可以在stop狀態(tài)下不開門，這也是正常的業(yè)務(wù)需求呀，你想想看，如果加上這些判斷條件，上面的程序有多少需要修改？看看我們的類，業(yè)務(wù)上的任務(wù)一個小小增加或改動都對我們的這個電梯類產(chǎn)生了修改，這是在項目開發(fā)上是有很大風險的

我們來思考兩個問題：

• 第一、這個停止狀態(tài)時怎么來的，那當然是由于電梯執(zhí)行了stop()方法而來的；
• 第二、在停止狀態(tài)下，電梯還能做什么動作?繼續(xù)運行？開門？那當然都可以了。

我們再來分析其他三個狀態(tài)，也都是一樣的結(jié)果，我們只要實現(xiàn)電梯在一個狀態(tài)下的兩個任務(wù)模型就可以了：這個狀態(tài)是如何產(chǎn)生的以及在這個狀態(tài)下還能做什么其他動作（也就是這個狀態(tài)怎么過渡到其他狀態(tài)），既然我們以狀態(tài)為參考模型，那我們就先定義電梯的狀態(tài)接口，思考過后我們來看類圖：

在類圖中，定義了一個LiftState抽象類，聲明了一個受保護的類型Context變量，這個是串聯(lián)我們各個狀態(tài)的封裝類，封裝的目的很明顯，就是電梯對象內(nèi)部狀態(tài)的變化不被調(diào)用類知曉，也就是迪米特法則了，我的類內(nèi)部情節(jié)你知道越少越好，并且還定義了四個具體的實現(xiàn)類，承擔的是狀態(tài)的產(chǎn)生以及狀態(tài)間的轉(zhuǎn)換過渡，全部的代碼如下：

public abstract class LiftState {

    /**
     * 定義一個環(huán)境角色，也就是封裝狀態(tài)的變換引起的功能變化
     */
    protected Context context;

    public void setContext(Context context) {
        this.context = context;
    }

    /**
     * 電梯門開啟動作
     */
    public abstract void open();

    /**
     * 電梯門關(guān)閉動作
     */
    public abstract void close();

    /**
     * 電梯運行動作
     */
    public abstract void run();

    /**
     * 電梯停止動作
     */
    public abstract void stop();

}

public class Context {

    /**
     * 定義出所有的電梯狀態(tài)
     */
    public static final OpeningState OPENING_STATE = new OpeningState();
    public static final ClosingState CLOSING_STATE = new ClosingState();
    public static final RunningState RUNNING_STATE = new RunningState();
    public static final StoppingState STOPPING_STATE = new StoppingState();

    /**
     * 定義一個當前電梯狀態(tài)
     */
    private LiftState liftState;

    public LiftState getLiftState() {
        return liftState;
    }

    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        // 把當前環(huán)境通知到各個實現(xiàn)類中
        this.liftState.setContext(this);
    }

    public void open() {
        liftState.open();
    }

    public void close() {
        liftState.close();
    }

    public void run() {
        liftState.run();
    }

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

}

public class OpeningState extends LiftState {

    @Override
    public void open() {
        System.out.println("電梯門開啟...");
    }

    @Override
    public void close() {
        // 修改狀態(tài)
        super.context.setLiftState(Context.CLOSING_STATE);
        // 動作委托CLOSING_STATE來執(zhí)行
        super.context.getLiftState().close();
    }

    /**
     * 打開狀態(tài)不能運行
     */
    @Override
    public void run() {
        // do nothing
    }

    /**
     * 打開狀態(tài)是停止狀態(tài)
     */
    @Override
    public void stop() {
        // do nothing
    }
}

public class ClosingState extends LiftState {

    @Override
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        System.out.println("電梯門關(guān)閉...");
    }

    @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();
    }
}

public class RunningState extends LiftState {

    @Override
    public void open() {
        // do nothing
    }

    @Override
    public void close() {
        // do nothing
    }

    @Override
    public void run() {
        System.out.println("電梯上下跑...");
    }

    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }
}

public class StoppingState extends LiftState {

    @Override
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        // do nothing
    }

    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

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

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();

    }

}

我們可以這樣理解，Context是一個環(huán)境角色，它的作用是串聯(lián)各個狀態(tài)的過渡，在LiftSate抽象類中我們定義了并把這個環(huán)境角色聚合進來，并傳遞到了子類，也就是四個具體的實現(xiàn)類中自己根據(jù)環(huán)境來決定如何進行狀態(tài)的過渡。

我們再來回顧一下我們剛剛批判上一段的代碼，首先我們說人家代碼太長，這個問題我們解決了，通過各個子類來實現(xiàn)，每個子類的代碼都很短，而且也取消了的switch…case條件的判斷；

其次，說人家不符合開閉原則，那如果在我們這個例子中要增加兩個狀態(tài)怎么加？增加兩個子類，一個是通電狀態(tài)，一個是斷電狀態(tài)，同時修改其他實現(xiàn)類的相應方法，因為狀態(tài)要過渡呀，那當然要修改原有的類，只是在原有類中的方法上增加，而不去做修改；

再其次，我們說人家不符合迪米特法則，我們現(xiàn)在呢是各個狀態(tài)是單獨的一個類，只有與這個狀態(tài)的有關(guān)的因素修改了這個類才修改，符合迪米特法則，非常完美!

上面例子中多次提到狀態(tài)，那我們這節(jié)講的就是狀態(tài)模式，什么是狀態(tài)模式呢？當一個對象內(nèi)在狀態(tài)改變時允許其改變行為，這個對象看起來像是改變了其類。說實話，這個定義的后半句我也沒看懂，看過GOF才明白是怎么回事: Allow an object to alter its behavior when its internal state changes. The object will appear to change its class，也就是說狀態(tài)模式封裝的非常好，狀態(tài)的變更引起了行為的變更，從外部看起來就好像這個對象對應的類發(fā)生了改變一樣。

狀態(tài)模式的通用實現(xiàn)類如下：

狀態(tài)模式中有什么優(yōu)點呢？

• 首先是避免了過多的swith…case或者if...else語句的使用，避免了程序的復雜性；
• 其次是很好的使用體現(xiàn)了開閉原則和單一職責原則，每個狀態(tài)都是一個子類，你要增加狀態(tài)就增加子類，你要修改狀態(tài)，你只修改一個子類就可以了；
• 最后一個好處就是封裝性非常好，這也是狀態(tài)模式的基本要求，狀態(tài)變換放置到了類的內(nèi)部來實現(xiàn)，外部的調(diào)用不用知道類內(nèi)部如何實現(xiàn)狀態(tài)和行為的變換。

狀態(tài)模式的缺點：類會太多，也就是類膨脹，一個事物有七八十來個狀態(tài)也不稀奇，如果完全使用狀態(tài)模式就會有太多的子類，不好管理。

狀態(tài)模式使用于當某個對象在它的狀態(tài)發(fā)生改變時，它的行為也隨著發(fā)生比較大的變化，也就是說行為是受狀態(tài)約束的情況下可以使用狀態(tài)模式，而且狀態(tài)模式使用時對象的狀態(tài)最好不要超過五個。

本文原書：

《您的設(shè)計模式》 作者：CBF4LIFE