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

時間 2019-12-08

標籤設計模式狀態简体版

原文原文鏈接

1、什麼是狀態模式

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

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

　　狀態模式（State），當一個對象的內在狀態改變時容許改變其行爲，這個對象看起來像是改變了其類。UML結構圖以下：學習

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

　　1. Context類

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

即把狀態對象聲明爲靜態常量，有幾個狀態對象就聲明幾個狀態常量
環境角色具備狀態抽象角色定義的全部行爲，具體執行使用委託方式

 1 public class Context {
 2 
 3     //定義狀態
 4     public final static State STATE1 = new ConcreteState1();
 5     public final static State STATE2 = new ConcreteState2();
 6     
 7     //當前狀態
 8     private State currentState;
 9     
10     //得到當前狀態
11     public State getCurrentState() {
12         return currentState;
13     }
14 
15     //設置當前狀態
16     public void setCurrentState(State currentState) {
17         this.currentState = currentState;
18 //        System.out.println("當前狀態：" + currentState);
19         //切換狀態
20         this.currentState.setContext(this);
21     }
22     
23     public void handle1() {
24         this.currentState.handle1();
25     }
26     public void handle2() {
27         this.currentState.handle2();
28     }
29     
30 }

　　2. State抽象狀態類

　　抽象環境中聲明一個環境角色，提供各個狀態類自行訪問，而且提供全部狀態的抽象行爲，由各個實現類實現。3d

 1 public abstract class State {
 2     
 3     protected Context context;
 4     public void setContext(Context context) {
 5         this.context = context;
 6     }
 7 
 8     //行爲1
 9     public abstract void handle1();
10     //行爲2
11     public abstract void handle2();
12     
13 }

　　3. 具體狀態

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

 1 public class ConcreteState1 extends State {
 2 
 3     @Override
 4     public void handle1() {
 5         //...
 6         System.out.println("ConcreteState1 的 handle1 方法");
 7     }
 8 
 9     @Override
10     public void handle2() {
11         super.context.setCurrentState(Context.STATE2);
12         System.out.println("ConcreteState1 的 handle2 方法");
13     }
14     
15 }

　　4. Client客戶端

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

 1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         //定義環境角色
 5         Context context = new Context();
 6         //初始化狀態
 7         context.setCurrentState(new ConcreteState1());
 8         //行爲執行
 9         context.handle1();
10         context.handle2();
11     }
12     
13 }

　　運行結果以下：blog

　　從運行結果可見，咱們已經隱藏了狀態的變化過程，它的切換引發了行爲的變化。對外來講，咱們只看到了行爲的改變，而不用知道是狀態變化引發的。接口

　　若是仍是有點不理解的話，參考一下下方第三部分的內容，狀態模式的具體實例便可。

2、狀態模式的應用

　　1. 什麼時候使用

代碼中包含大量與對象狀態有關的條件語句

　　2. 方法

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

　　3. 優勢

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

　　4. 缺點

子類會太多，也即類膨脹

　　5. 使用場景

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

　　6. 應用實例

電梯，有運行狀態、開門狀態、閉門狀態、中止狀態等
一日從早到晚自身的狀態，好比工做狀態、學習狀態等等
運動員能夠有正常狀態、非正常狀態和超長狀態

　　7. 注意事項

在行爲受狀態約束的狀況下可使用狀態模式，使用時對象的狀態最好不要超過5個

3、狀態模式的實現

　　咱們常常坐電梯都知道，電梯有多種狀態，就按最簡單的來講，包括運行狀態、中止狀態、開門狀態、閉門狀態。下面就以電梯運行爲例，舉一個具體的實例，UML圖以下：

　　1. 環境角色Context

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

 1 public class Context {
 2     
 3     //定義出電梯的全部狀態
 4     public final static LiftState OPENNING_STATE = new OpenningState();
 5     public final static LiftState CLOSING_STATE = new ClosingState();
 6     public final static LiftState RUNNING_STATE = new RunningState();
 7     public final static LiftState STOPPING_STATE = new StoppingState();
 8     
 9     //定義一個當前電梯狀態
10     private LiftState liftState;
11 
12     public LiftState getLiftState() {
13         return liftState;
14     }
15 
16     public void setLiftState(LiftState liftState) {
17         this.liftState = liftState;
18         //通知到各個實現類中
19         this.liftState.setContext(this);
20     }
21     
22     public void open() {
23         this.liftState.open();
24     }
25     
26     public void close() {
27         this.liftState.close();
28     }
29     
30     public void run() {
31         this.liftState.run();
32     }
33 
34     public void stop() {
35         this.liftState.stop();
36     }
37 }

　　2. 抽象電梯狀態LiftState

　　這裏咱們定義並把Context這個環境角色聚合進來，並傳遞到子類。因此咱們能夠這樣理解，Context環境角色的做用就是串聯各個狀態的過渡，也就是在4個具體的實現類中，各自根據本身的環境來決定如何進行狀態的過渡。

 1 public abstract class LiftState {
 2 
 3     protected Context context;
 4     
 5     public void setContext(Context context) {
 6         this.context = context;
 7     }
 8     
 9     //電梯門開啓動做
10     public abstract void open();
11     //電梯門關閉動做
12     public abstract void close();
13     //電梯運行
14     public abstract void run();
15     //電梯中止
16     public abstract void stop();
17     
18 }

　　3. 電梯開門狀態

　　對於開門狀態，除去自身的開啓電梯門的方法以外，在打開門以後應該還具有關閉電梯門的功能，而門開着的時候是不能運行也不能中止的。

 1 public class OpenningState extends LiftState {
 2     
 3     //執行打開電梯門方法
 4     @Override
 5     public void open() {
 6         System.out.println("電梯門開啓");
 7     }
 8 
 9     //打開後還能夠關閉電梯門
10     @Override
11     public void close() {
12         //狀態修改
13         super.context.setLiftState(Context.CLOSING_STATE);
14         //動做委託爲CLOSING_STATE執行
15         super.context.getLiftState().close();
16     }
17 
18     //門開着不能運行
19     @Override
20     public void run() {
21         //什麼都不作
22     }
23 
24     //門開着已經中止了
25     @Override
26     public void stop() {
27         //什麼都不作
28     }
29 
30 }

　　4. 電梯閉門狀態

　　對於閉門狀態，除去自身外，電梯門關閉以後還能夠再度打開，因此有open()方法；而門關了以後是能夠運行的，因此有run()方法；若是關了門沒有按樓層的話，此時電梯處於中止狀態，因此有stop()方法。

 1 public class ClosingState extends LiftState {
 2 
 3     //電梯門關了能夠再開
 4     @Override
 5     public void open() {
 6         //置爲敞門狀態
 7         super.context.setLiftState(Context.OPENNING_STATE);
 8         super.context.getLiftState().open();
 9     }
10 
11     // * 執行電梯門關閉方法
12     @Override
13     public void close() {
14         System.out.println("電梯門關閉");
15     }
16 
17     //電梯門關了就運行
18     @Override
19     public void run() {
20         super.context.setLiftState(Context.RUNNING_STATE);
21         super.context.getLiftState().run();
22     }
23 
24     //電梯門關了但沒有按樓層
25     @Override
26     public void stop() {
27         super.context.setLiftState(Context.STOPPING_STATE);
28         super.context.getLiftState().stop();
29     }
30 
31 }

　　5. 電梯運行狀態

　　當電梯處於運行狀態時，此時固然是不能開門的；而門確定是關了的，因此也沒必要執行關門方法；此時電梯能夠從運行狀態轉變爲中止狀態。

 1 public class RunningState extends LiftState {
 2 
 3     //運行時不能開門
 4     @Override
 5     public void open() {
 6         //什麼都不作
 7     }
 8 
 9     //運行時門確定是關的
10     @Override
11     public void close() {
12         //什麼都不作
13     }
14 
15     // * 執行運行方法
16     @Override
17     public void run() {
18         System.out.println("電梯運行中");
19     }
20 
21     //運行後能夠中止
22     @Override
23     public void stop() {
24         //環境設置爲中止狀態
25         super.context.setLiftState(Context.STOPPING_STATE);
26         super.context.getLiftState().stop();
27     }
28 
29 }

　　6. 電梯中止狀態

　　當電梯處於中止狀態時，門是關閉着的，因此不能執行關門的方法；但此時是能夠開門的；而中止後電梯也能夠再度運行，因此存在run()方法。

 1 public class StoppingState extends LiftState {
 2 
 3     //停下了要開門
 4     @Override
 5     public void open() {
 6         super.context.setLiftState(Context.OPENNING_STATE);
 7         super.context.getLiftState().open();
 8     }
 9 
10     //門原本就是關着的
11     @Override
12     public void close() {
13         //什麼都不作
14     }
15 
16     //中止後能夠再運行
17     @Override
18     public void run() {
19         super.context.setLiftState(Context.RUNNING_STATE);
20         super.context.getLiftState().run();
21     }
22 
23     //執行中止方法
24     @Override
25     public void stop() {
26         System.out.println("電梯中止了");
27     }
28 
29 }

　　7. Client客戶端

　　這裏假設初始狀態爲閉門狀態，你們能夠自行嘗試其它初始值。

 1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         Context context = new Context();
 5         
 6         //定義初始狀態爲關門（共四種初始值）
 7         context.setLiftState(new ClosingState());
 8         context.open();
 9         context.close();
10         context.run();
11         context.stop();
12     }
13     
14 }

　　運行結果以下：

　　若是將setLiftState()方法的參數換成運行狀態，即 context.setLiftState(new RunningState()); ，運行結果以下：

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

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

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