# 狀態設計模式 > 原文： [https://howtodoinjava.com/design-patterns/behavioral/state-design-pattern/](https://howtodoinjava.com/design-patterns/behavioral/state-design-pattern/) **狀態模式**是**行為型**設計模式。 根據 GoF 定義，狀態**允許對象在其內部狀態更改時更改其行為**。 該對象似乎將更改其類。 從上面的定義可以得出，對象的每個可能狀態應有一個**單獨的具體類**。 每個具體的狀態對象都有邏輯，可以根據其當前狀態和作為方法參數傳遞給它的上下文信息來接受或拒絕狀態轉換請求。 ## 1.何時使用狀態模式 在任何應用中，當我們處理對象時，該對象在其生命周期期間可能處于不同的狀態，以及如何根據其當前狀態處理傳入的請求（或進行狀態轉換）– 我們可以使用狀態模式。 如果在這種情況下不使用狀態模式，則最終將有很多[`if-else`](https://howtodoinjava.com/java/basics/if-else-statement-in-java/)語句，這些語句會使代碼庫變得丑陋，不必要地復雜且難以維護。 狀態模式允許對象根據當前狀態表現不同，并且我們可以在不同類中定義特定于狀態的行為。 > 狀態模式解決了對象在其內部狀態更改時應更改其行為的問題。 同樣，添加新狀態不應影響現有狀態的行為。 ## 2.狀態模式的真實例子 * 為簡單起見，讓我們想象一下通過遙控器操作的“電視盒”。 我們可以通過按遙控器上的按鈕來更改電視的狀態。 但是電視的狀態是否會改變，取決于電視的當前狀態。 如果電視已打開，我們可以將其關閉，靜音或更改顯示方式和來源。 但是，如果電視關閉，當我們按遙控器按鈕時將什么也不會發生。 對于關閉的電視。 只有可能的下一個狀態才能打開。 * 狀態模式用于在復雜的應用中實現狀態機的實現。 * 另一個示例可以是 [**Java 線程**狀態](https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/)。 線程可以是其生命周期中的五個狀態之一。 只有在獲得當前狀態后才能確定其下一個狀態。 例如，我們無法啟動已停止的線程，也無法讓線程等待，直到線程開始運行。 ## 3.狀態設計模式的實現 定義單獨的（狀態）對象，這些對象封裝每個狀態的特定于狀態的行為。 即，定義用于執行特定于狀態的行為的接口（狀態），并定義實現每個狀態的接口的類。 狀態模式未指定狀態轉換的定義位置。 選擇有兩個：“上下文”對象，或每個單獨的狀態派生類。 #### 3.1 架構  狀態設計模式 #### 3.2 設計參與者 * **`State`** – 接口定義每個狀態必須處理的操作。 * **`ConcreteState`** – 包含狀態特定行為的類。 * **`Context`** – 定義與客戶端進行交互的接口。 它維護對具體狀態對象的引用，這些引用可用于定義對象的當前狀態。 它將特定于狀態的行為委派給不同的`State`對象。 ## 4.狀態模式示例 在此示例中，我們模擬了快遞遞送系統，其中包裹在轉換過程中可能處于不同狀態。 ```java public interface PackageState { public void updateState(DeliveryContext ctx); } ``` ```java public class Acknowledged implements PackageState { //Singleton private static Acknowledged instance = new Acknowledged(); private Acknowledged() {} public static Acknowledged instance() { return instance; } //Business logic and state transition @Override public void updateState(DeliveryContext ctx) { System.out.println("Package is acknowledged !!"); ctx.setCurrentState(Shipped.instance()); } } ``` ```java public class Shipped implements PackageState { //Singleton private static Shipped instance = new Shipped(); private Shipped() {} public static Shipped instance() { return instance; } //Business logic and state transition @Override public void updateState(DeliveryContext ctx) { System.out.println("Package is shipped !!"); ctx.setCurrentState(InTransition.instance()); } } ``` ```java public class InTransition implements PackageState { //Singleton private static InTransition instance = new InTransition(); private InTransition() {} public static InTransition instance() { return instance; } //Business logic and state transition @Override public void updateState(DeliveryContext ctx) { System.out.println("Package is in transition !!"); ctx.setCurrentState(OutForDelivery.instance()); } } ``` ```java public class OutForDelivery implements PackageState { //Singleton private static OutForDelivery instance = new OutForDelivery(); private OutForDelivery() {} public static OutForDelivery instance() { return instance; } //Business logic and state transition @Override public void updateState(DeliveryContext ctx) { System.out.println("Package is out of delivery !!"); ctx.setCurrentState(Delivered.instance()); } } ``` ```java public class Delivered implements PackageState { //Singleton private static Deliveredinstance = new Delivered(); private Delivered() {} public static Deliveredinstance() { return instance; } //Business logic @Override public void updateState(DeliveryContext ctx) { System.out.println("Package is delivered!!"); } } ``` **上下文** ```java public class DeliveryContext { private PackageState currentState; private String packageId; public DeliveryContext(PackageState currentState, String packageId) { super(); this.currentState = currentState; this.packageId = packageId; if(currentState == null) { this.currentState = Acknowledged.instance(); } } public PackageState getCurrentState() { return currentState; } public void setCurrentState(PackageState currentState) { this.currentState = currentState; } public String getPackageId() { return packageId; } public void setPackageId(String packageId) { this.packageId = packageId; } public void update() { currentState.updateState(this); } } ``` 現在測試代碼。 ```java public class Main { public static void main(String[] args) { DeliveryContext ctx = new DeliveryContext(null, "Test123"); ctx.update(); ctx.update(); ctx.update(); ctx.update(); ctx.update(); } } ``` 程序輸出。 ```java Package is acknowledged !! Package is shipped !! Package is in transition !! Package is out of delivery !! Package is delivered !! ``` ## 5.常見問題 #### 5.1 狀態模式與策略模式 兩種模式的結構相似，但目的不同。 [策略模式](https://howtodoinjava.com/design-patterns/behavioral/strategy-design-pattern/)為子類提供了更好的選擇，而在狀態模式下 – 行為封裝在單獨的類中。 然而，兩者都促進了繼承的組合和委托。 #### 5.2 狀態對象應該是單例嗎？ 是。 始終嘗試使狀態對象[單例](https://howtodoinjava.com/design-patterns/creational/singleton-design-pattern-in-java/)。 #### 5.3 狀態設計模式的優勢？ 我們可以輕松地在應用中添加新狀態和新行為，而不會影響其他組件。 它還通過減少對`if-else`語句或[`switch/case`](https://howtodoinjava.com/java/basics/switch-statement-in-java/)條件邏輯的使用來幫助降低復雜度。 #### 5.4 狀態設計模式的缺點？ 狀態模式也稱為狀態的**對象**。 因此，我們可以假設更多的狀態需要更多的代碼，并且明顯的副作用對我們來說很難維護。 學習愉快！ 閱讀更多： [維基百科](https://en.wikipedia.org/wiki/State_pattern)