23種設計模式(七)-狀態設計模式

盛開的太陽發表於2021-07-07

一. 什麼是狀態模式?

狀態模式（State Pattern）：它主要用來解決物件在多種狀態轉換時，需要對外輸出不同的行為的問題。狀態和行為是一一對應的，狀態之間可以相互轉換。當一個物件的內在狀態改變時，允許改變其行為，這個物件看起來像是改變了其類。例如：淘寶下單，訂單有待付款，已付款待發貨，待收貨，待評價, 已完成等狀態。每個狀態對應的行為都是不同的，一個狀態完成會流轉到下一個狀態。

通常對有狀態的物件進行程式設計，我們的解決方案是：思考可能存在的所有狀態，然後使用 if-else 或 switch-case 語句來進行狀態判斷，然後再根據不同的狀態進行不同的處理。如上面的案例--淘寶下單:

public class ClientApplication {
    public static void main(String[] args) {
        String status = "待付款";
        if ("待付款".equals(status)) {
            // 執行付款邏輯
        } else if("待發貨".equals(status)) {
            // 執行發貨邏輯
        } else if("待收貨".equals(status)) {
            // 執行收貨邏輯
        } else if("待評價".equals(status)) {
            // 執行評價邏輯
        } else if("待收貨".equals(status)) {
            // 執行收穫邏輯
        }
    }
}

大量的if...else的缺點很明顯

違背開閉原則: 當增加一種狀態的時候, 需要修改原來的邏輯
當狀態很多的時候, 程式碼段很長, 臃腫, 不容易維護, 可擴充套件性差.

狀態模式可以很好地解決這個問題。
狀態模式的思想：當是條件語句表示一個物件狀態轉換過於複雜時，可以把條件判斷中的“判斷邏輯”提取出來，放在單獨的類中，當前上下文處於那種狀態，直接用相應的狀態類物件進行處理，這樣的好處是:能把原來複雜的判斷邏輯簡單化，消除了 if-else、switch-case 等條件判斷語句，程式碼更有層次性，且具備良好的擴充套件力, 可維護性。

二. 狀態模式的結構

狀態模式把因環境改變而變化的物件行為包裝在不同的狀態類中，其目的保證物件的狀態變化時, 其行為也隨之改變。接下來, 我們來看看狀態模式的結構。

從中我們可以看出有四個組成部分:

1. 環境類

環境類也是上下文類, 狀態的變化依賴於環境, 環境記錄當前的狀態. 環境類擁有多種狀態的物件. 環境類的狀態存在多樣性, 不同狀態下物件的行為有所不同, 因此將狀態獨立出去形成單獨的狀態類。

> 1) 在環境類中維護一個抽象狀態State的例項, 這個例項儲存當前狀態。
> 2) 在環境類中定義所有狀態執行的方法.

package com.lxl.www.designPatterns.statePattern.context;

/**
 * 上下文環境類
 */
public class Context {
    // 在環境類中維護一個抽象狀態State的例項, 這個例項儲存當前狀態。
    private State state;
    public Context() {
        this.state = new ConcreteStateA(this);
    }

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

    /**
     * 在環境類中定義所有狀態執行的方法.
     */
    public void handler1() {

        this.state.handler1();
    }

    public void handler2() {
        this.state.handler2();
    }

}

2. State抽象狀態類

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

/**
 * 狀態抽象類
 */
public abstract class State {

    /**
     * 環境上下文
     */
    public Context context;
    public State(Context context) {
        this.context = context;
    }

    /**
     * 定義了所有狀態的抽象方法
     */
    abstract void handler1();
    abstract void handler2();
}

3. 具體狀態

　　具體狀態實現，這裡以定義ConcreteStateA、ConcreteStateB、ConcreteStateC三個具體狀態類。具體狀態類繼承自State抽象類，並實現抽象方法。

package com.lxl.www.designPatterns.statePattern.context;

public class ConcreteStateA extends State{

    public ConcreteStateA(Context context) {
        super(context);
    }

    @Override
    void handler1() {
        System.out.println("執行ConcreteStateA中handler1的邏輯");
        this.context.setState(new ConcreteStateB(context));
    }

    @Override
    void handler2() {
        System.out.println("執行ConcreteStateA中handler2的邏輯");
        this.context.setState(new ConcreteStateC(context));
    }
}

在這裡，我們重寫了狀態類的狀態方法。當執行完方法一的業務邏輯後, 將狀態變更為 ConcreteStateB. 執行完handler2的業務邏輯後, 將狀態變更為ConcreteStateC。
這種自動變更狀態，在呼叫方是無感知的。

4. Client客戶端

　　構建Context環境上下文類的例項物件，初始化時設定初始狀態是ConcreteStateA，執行行為觀察結果。

package com.lxl.www.designPatterns.statePattern.context;

public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.handler1();
        context.handler1();
        context.handler1();
        context.handler2();
    }
}

全部原始碼:

package com.lxl.www.designPatterns.statePattern.context;

/**
 * 上下文環境類
 */
public class Context {
    // 在環境類中維護一個抽象狀態State的例項, 這個例項儲存當前狀態。
    private State state;
    public Context() {
        this.state = new ConcreteStateA(this);
    }

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

    /**
     * 在環境類中定義所有狀態執行的方法.
     */
    public void handler1() {

        this.state.handler1();
    }

    public void handler2() {
        this.state.handler2();
    }

}



/**
 * 狀態抽象類
 */
public abstract class State {

    /**
     * 環境上下文
     */
    public Context context;
    public State(Context context) {
        this.context = context;
    }

    /**
     * 定義了所有狀態的抽象方法
     */
    abstract void handler1();
    abstract void handler2();
}



public class ConcreteStateA extends State{

    public ConcreteStateA(Context context) {
        super(context);
    }

    @Override
    void handler1() {
        System.out.println("執行ConcreteStateA中handler1的邏輯");
        this.context.setState(new ConcreteStateB(context));
    }

    @Override
    void handler2() {
        System.out.println("執行ConcreteStateA中handler2的邏輯");
        this.context.setState(new ConcreteStateC(context));
    }
}

public class ConcreteStateB extends State{
    public ConcreteStateB(Context context) {
        super(context);
    }

    @Override
    void handler1() {
        System.out.println("執行ConcreteStateB中handler1的邏輯");
        this.context.setState(new ConcreteStateC(context));
    }

    @Override
    void handler2() {
        System.out.println("執行ConcreteStateB中handler2的邏輯");
        this.context.setState(new ConcreteStateA(context));
    }
}



public class ConcreteStateC extends State{
    public ConcreteStateC(Context context) {
        super(context);
    }

    @Override
    void handler1() {
        System.out.println("執行ConcreteStateC中handler1的邏輯");
        this.context.setState(new ConcreteStateA(context));
    }

    @Override
    void handler2() {
        System.out.println("執行ConcreteStateC中handler2的邏輯");
        this.context.setState(new ConcreteStateB(context));
    }
}



public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.handler1();
        context.handler1();
        context.handler1();
        context.handler1();
    }
}

客戶端直接結果分析:

Context例項花的時候, 狀態是 ConcreteStateA
第一次執行context.handler1();將狀態切換到了ConcreteStateB
第二次執行context.handler1();將狀態切換到了ConcreteStateC
第三次執行context.handler1();將狀態切換到了ConcreteStateA

所以, 最後的執行結果是:

執行ConcreteStateA中handler1的邏輯

執行ConcreteStateB中handler1的邏輯

執行ConcreteStateC中handler1的邏輯

執行ConcreteStateA中handler1的邏輯

三. 狀態模式的應用例項

下面以商品下單為例，來看看狀態模式的應用。

在電商系統購物的過程中，訂單一般有這幾種狀態，待付款，待出庫，待收貨，待評價，完成。不同的狀態下，使用者看到的行為是不同的。

我們由淺入深，來看看幾種狀態模式的實現。

第一種：狀態是一條線的實現邏輯

先來看看這種方法的流程：

這種狀態的特點是：上一個狀態流轉到下一個狀態，下一個流轉到下下個，以此類推。直到最後一個沒有狀態流轉了。來看看原始碼:

第一步：定義上下文環境類。

用orderStatus來記錄當前的狀態。並定義了所有狀態的方法。

package com.lxl.www.designPatterns.statePattern.order;

/**
 * 訂單上下文
 */
public class OrderContext {

    /**在上下文類中記錄訂單狀態*/
    private IOrderStatus orderStatus;

    public OrderContext() {
        // 最開始是待付款狀態
        this.orderStatus = new Pending();
    }

    public void setOrderStatus(IOrderStatus orderStatus) {
        this.orderStatus = orderStatus;
    }

    /**
     * 業務邏輯操作
     */
    public void businessHandler() {
        this.orderStatus.businessHandler(this);
    }

    /**
     * 列印當前業務
     */
    public void printInfo() {
        this.orderStatus.printInfo();
    }
}

第二步：定義狀態抽象類。

裡面定義所有狀態類要實現的方法。

package com.lxl.www.designPatterns.statePattern.order;

/**
 * 訂單狀態
 */
public interface IOrderStatus {
    void businessHandler(OrderContext context);

    void printInfo();
}

這裡面就有兩個方法，一個是狀態要執行的業務邏輯，另一個是列印當前狀態。

第三步：定義狀態具體類。

這裡定義了5個具體類，分別是：待付款，待出庫，待收貨，待評價，完成

package com.lxl.www.designPatterns.statePattern.order;
/**
 * 待付款
 */
public class Pending implements IOrderStatus{
    @Override
    public void businessHandler(OrderContext context) {
        //執行業務, 完成付款, 進入到下一個狀態
        System.out.println("付款完成");
        context.setOrderStatus(new WaitOut());
    }

    @Override
    public void printInfo() {
        System.out.println("當前狀態等::待付款");
    }
}


package com.lxl.www.designPatterns.statePattern.order;
/**
 * 待出庫
 */
public class WaitOut implements IOrderStatus{
    @Override
    public void businessHandler(OrderContext context) {
        //執行業務, 完成付款, 進入到下一個狀態
        System.out.println("貨物已出庫");
        context.setOrderStatus(new WaitReceive());
    }

    @Override
    public void printInfo() {
        System.out.println("當前狀態等::待出庫");
    }
}


package com.lxl.www.designPatterns.statePattern.order;
/**
 * 待收貨
 */
public class WaitReceive implements IOrderStatus {
    @Override
    public void businessHandler(OrderContext context) {
        //執行業務, 完成付款, 進入到下一個狀態
        System.out.println("已經收貨");
        context.setOrderStatus(new OrderEvaluation());
    }

    @Override
    public void printInfo() {
        System.out.println("當前狀態等::待收貨");
    }
}


package com.lxl.www.designPatterns.statePattern.order;
/**
 * 訂單評價
 */
public class OrderEvaluation implements IOrderStatus{
    @Override
    public void businessHandler(OrderContext context) {
        //執行業務, 完成付款, 進入到下一個狀態
        System.out.println("已經評價");
        context.setOrderStatus(new Finish());
    }

    @Override
    public void printInfo() {
        System.out.println("當前狀態等::待評價");
    }
}


package com.lxl.www.designPatterns.statePattern.order;
/**
 * 訂單完成
 */
public class Finish implements IOrderStatus{
    @Override
    public void businessHandler(OrderContext context) {
        // 執行業務, 完成付款, 進入到下一個狀態
        System.out.println("完成工作處理完畢");
    }

    @Override
    public void printInfo() {
        System.out.println("當前狀態::訂單完成");
    }
}

第四步：定義客戶端類，模擬下單的流程

package com.lxl.www.designPatterns.statePattern.order;

public class OrderClient {
    public static void main(String[] args) {
        OrderContext orderContext = new OrderContext();

        // 開始下單
        System.out.println("==========開始下單==========");
        orderContext.printInfo();

        // 付款
        System.out.println("==========付款==========");
        orderContext.businessHandler();
        orderContext.printInfo();

        // 貨物出庫
        System.out.println("==========貨物出庫==========");
        orderContext.businessHandler();
        orderContext.printInfo();

        // 收貨
        System.out.println("==========收貨==========");
        orderContext.businessHandler();
        orderContext.printInfo();

        // 評價訂單
        System.out.println("==========評價訂單==========");
        orderContext.businessHandler();
        orderContext.printInfo();

        // 訂單完成
        System.out.println("==========訂單完成==========");
        orderContext.businessHandler();
    }
}

接下來我們來看看執行效果：

開始下單

當前狀態等::待付款

付款

付款完成

當前狀態等::待出庫

貨物出庫

貨物已出庫

當前狀態等::待收貨

收貨

已經收貨

當前狀態等::待評價

評價訂單

已經評價

當前狀態::訂單完成

訂單完成

完成工作處理完畢

第二種：帶有取消付款和退貨退款狀態。

退貨退款最開始只能是收到貨以後才能退。

這種方式和第一個有所不同，待付款和確認收貨不止有一個狀態流轉，當有多個狀態流轉，甚至是更多的狀態是，我們應該如何處理呢？

第一步：定義上下文環境類。

這裡環境上下文定義了所有的狀態方法。

package com.lxl.www.designPatterns.statePattern.order2;

/**
 * 訂單上下文
 */
public class OrderContext {

    /**在上下文類中記錄訂單狀態*/
    private IOrderStatus orderStatus;

    public OrderContext() {
        System.out.println("開始購物");
        // 最開始是待付款狀態
        this.orderStatus = new Pending();
    }

    public void setOrderStatus(IOrderStatus orderStatus) {
        this.orderStatus = orderStatus;
    }


    /**
     * 付款完成
     */
    public void pending() {
        this.orderStatus.pending(this);
    }

    public void waitOut() {
        this.orderStatus.waitOut(this);
    }

    public void waitReceive() {
        this.orderStatus.waitReceive(this);
    }

    public void confirmReceived() {
        this.orderStatus.confirmReceived(this);
    }

    public void orderEvaluation() {
        this.orderStatus.orderEvaluation(this);
    }

    public void finish() {
        this.orderStatus.finish(this);
    }

    public void cancelPay() {
        this.orderStatus.cancelPay(this);
    }

    public void refunds() {
        this.orderStatus.refunds(this);
    }

}

第二步：定義抽象狀態類

package com.lxl.www.designPatterns.statePattern.order2;

/**
 * 訂單狀態
 */
public interface IOrderStatus {
    /*
     * 待付款
     */
    void pending(OrderContext context);

    /*
     * 取消付款
     */
    void cancelPay(OrderContext context);

    /*
     * 待出庫
     */
    void waitOut(OrderContext context);

    /*
     * 退貨退款
     */
    void refunds(OrderContext context);

    /*
     * 待收貨
     */
    void waitReceive(OrderContext context);

    /*
     * 確認收貨
     */
    void confirmReceived(OrderContext context);

    /*
     * 訂單評價
     */
    void orderEvaluation(OrderContext context);

    /*
     * 訂單完成
     */
    void finish(OrderContext context);

}

第三步：定義具體狀態類。

我們這裡定義了待付款，待出庫，待收貨，確認收貨，訂單評價，訂單完成，取消付款，退貨退款一共8個狀態。

待付款

package com.lxl.www.designPatterns.statePattern.order2;

/**
 * 待付款
 */
public class Pending implements IOrderStatus {
    public Pending() {
        System.out.println("當前狀態::待付款");

    }

    @Override
    public void pending(OrderContext context) {
        System.out.println("付款完成了, 待出庫");
        context.setOrderStatus(new WaitOut());
    }

    /*
     * 取消付款
     */
    public void cancelPay(OrderContext context) {
        System.out.println("取消付款");
        context.setOrderStatus(new Finish());
    }

    @Override
    public void waitOut(OrderContext context) {
        System.out.println("去付款-->付款完成,待出庫");
        context.setOrderStatus(new WaitOut());
    }

    /*
     * 退貨退款
     */
    public void refunds(OrderContext context) {

    }

    @Override
    public void waitReceive(OrderContext context) {

    }

    @Override
    public void confirmReceived(OrderContext context) {

    }

    @Override
    public void orderEvaluation(OrderContext context) {

    }

    @Override
    public void finish(OrderContext context) {

    }
}

待出庫

package com.lxl.www.designPatterns.statePattern.order2;

/**
 * 待出庫
 */
public class WaitOut implements IOrderStatus {

    public WaitOut() {
        System.out.println("當前狀態::待出庫");
    }

    @Override
    public void pending(OrderContext context) {

    }

    @Override
    public void cancelPay(OrderContext context) {

    }

    /*
     * 退貨退款
     */
    public void refunds(OrderContext context) {
        System.out.println("申請退貨");
        context.setOrderStatus(new Refunds());
    }

    @Override
    public void waitOut(OrderContext context) {
        System.out.println("出庫完成, 待收貨");
        context.setOrderStatus(new WaitReceive());
    }

    @Override
    public void waitReceive(OrderContext context) {

    }

    @Override
    public void confirmReceived(OrderContext context) {

    }

    @Override
    public void orderEvaluation(OrderContext context) {

    }

    @Override
    public void finish(OrderContext context) {

    }
}

待收貨

package com.lxl.www.designPatterns.statePattern.order2;

/**
 * 待收貨
 */
public class WaitReceive implements IOrderStatus {

    public WaitReceive() {
        System.out.println("當前狀態 :: 待收貨");
    }

    @Override
    public void pending(OrderContext context) {

    }

    @Override
    public void cancelPay(OrderContext context) {

    }

    @Override
    public void waitOut(OrderContext context) {

    }

    /*
     * 退貨退款
     */
    public void refunds(OrderContext context) {
        System.out.println("申請退貨");
        context.setOrderStatus(new Refunds());
    }

    @Override
    public void waitReceive(OrderContext context) {
        System.out.println("進行收貨, 完成收貨動作");
        context.setOrderStatus(new Confirm());

    }

    @Override
    public void confirmReceived(OrderContext context) {

    }

    @Override
    public void orderEvaluation(OrderContext context) {

    }

    @Override
    public void finish(OrderContext context) {

    }
}

確認收貨

package com.lxl.www.designPatterns.statePattern.order2;

public class Confirm implements IOrderStatus{

    public Confirm() {
        System.out.println("當前狀態 :: 確認收貨");
    }
    @Override
    public void pending(OrderContext context) {

    }

    @Override
    public void cancelPay(OrderContext context) {

    }

    @Override
    public void waitOut(OrderContext context) {

    }

    @Override
    public void refunds(OrderContext context) {
        System.out.println("申請退款");
        context.setOrderStatus(new Refunds());
    }

    @Override
    public void waitReceive(OrderContext context) {

    }

    @Override
    public void confirmReceived(OrderContext context) {
        System.out.println("確認收貨了");
        context.setOrderStatus(new OrderEvaluation());
    }

    @Override
    public void orderEvaluation(OrderContext context) {

    }

    @Override
    public void finish(OrderContext context) {

    }
}

訂單評價

package com.lxl.www.designPatterns.statePattern.order2;

import com.sun.tools.corba.se.idl.constExpr.Or;

/**
 * 訂單評價
 */
public class OrderEvaluation implements IOrderStatus {

    public OrderEvaluation() {
        System.out.println("當前狀態 :: 訂單待評價");
    }

    @Override
    public void pending(OrderContext context) {

    }

    @Override
    public void cancelPay(OrderContext context) {

    }

    @Override
    public void waitOut(OrderContext context) {

    }

    @Override
    public void refunds(OrderContext context) {

    }

    @Override
    public void waitReceive(OrderContext context) {

    }

    @Override
    public void confirmReceived(OrderContext context) {

    }

    @Override
    public void orderEvaluation(OrderContext context) {
        System.out.println("訂單評價完了");
        context.setOrderStatus(new Finish());
    }

    @Override
    public void finish(OrderContext context) {

    }
}

訂單完成

package com.lxl.www.designPatterns.statePattern.order2;

/**
 * 訂單完成
 */
public class Finish implements IOrderStatus {

    @Override
    public void pending(OrderContext context) {

    }

    @Override
    public void cancelPay(OrderContext context) {

    }

    @Override
    public void waitOut(OrderContext context) {

    }

    /*
     * 退貨退款
     */
    public void refunds(OrderContext context) {

    }

    @Override
    public void waitReceive(OrderContext context) {

    }

    @Override
    public void confirmReceived(OrderContext context) {

    }

    @Override
    public void orderEvaluation(OrderContext context) {

    }

    @Override
    public void finish(OrderContext context) {
        System.out.println("訂單完成");
    }
}

取消付款

package com.lxl.www.designPatterns.statePattern.order2;

/**
 * 取消付款
 */
public class CancelPay implements IOrderStatus {

    @Override
    public void pending(OrderContext context) {

    }

    /*
     * 取消付款
     */
    public void cancelPay(OrderContext context) {

    }

    @Override
    public void waitOut(OrderContext context) {

    }

    /*
     * 退貨退款
     */
    public void refunds(OrderContext context) {

    }

    @Override
    public void waitReceive(OrderContext context) {

    }

    @Override
    public void confirmReceived(OrderContext context) {

    }

    @Override
    public void orderEvaluation(OrderContext context) {

    }

    @Override
    public void finish(OrderContext context) {

    }
}

退貨退款

package com.lxl.www.designPatterns.statePattern.order2;

public class Refunds implements IOrderStatus{

    public Refunds() {
        System.out.println("當前狀態 :: 退貨退款");
    }

    @Override
    public void pending(OrderContext context) {

    }

    @Override
    public void cancelPay(OrderContext context) {

    }

    @Override
    public void waitOut(OrderContext context) {

    }

    @Override
    public void refunds(OrderContext context) {
        System.out.println("退款完成");
        context.setOrderStatus(new Finish());
    }

    @Override
    public void waitReceive(OrderContext context) {

    }

    @Override
    public void confirmReceived(OrderContext context) {

    }

    @Override
    public void orderEvaluation(OrderContext context) {

    }

    @Override
    public void finish(OrderContext context) {

    }
}

我們看得出來，這些狀態子類，繼承了父類所有的方法，但是卻沒有實現所有的方法。而是隻實現了和自己有關係的一部分方法。這也是我們後面需要優化的地方

第四步：客戶端呼叫

package com.lxl.www.designPatterns.statePattern.order2;

public class OrderClient {
    public static void main(String[] args) {
        System.out.println("==========張三   開始下單==========");
        OrderContext o1 = new OrderContext();

        System.out.println("===========取消付款==============");
        o1.cancelPay();
        o1.finish();


        System.out.println();
        System.out.println();
        System.out.println("==========李四    開始下單==========");
        OrderContext o2 = new OrderContext();

        System.out.println("===========付款==============");
        o2.pending();

        System.out.println("===========退貨退款==============");
        o2.refunds();
        o2.refunds();
        o2.finish();


        System.out.println();
        System.out.println();
        System.out.println("==========王五    開始下單==========");
        OrderContext o3 = new OrderContext();

        System.out.println("===========付款==============");
        o3.pending();

        System.out.println("===========出庫==============");
        o3.waitOut();

        System.out.println("===========收貨==============");
        o3.waitReceive();

        System.out.println("===========確認收貨==============");
        o3.confirmReceived();

        System.out.println("===========訂單評價==============");
        o3.orderEvaluation();

        System.out.println("===========訂單完成==============");
        o3.finish();
    }
}

來看看執行效果：

張三開始下單

開始購物

當前狀態::待付款

=取消付款====

取消付款

訂單完成

李四開始下單

開始購物

當前狀態::待付款

=付款

付款完成了, 待出庫

當前狀態::待出庫

=退貨退款

申請退貨

當前狀態 :: 退貨退款

退款完成

訂單完成

王五開始下單

開始購物

當前狀態::待付款

=付款

付款完成了, 待出庫

當前狀態::待出庫

=出庫

出庫完成, 待收貨

當前狀態 :: 待收貨

=收貨

進行收貨, 完成收貨動作

當前狀態 :: 確認收貨

=確認收貨

確認收貨了

當前狀態 :: 訂單待評價

=訂單評價

訂單評價完了

=訂單完成

訂單完成

第三種：完善方案二

方案二違背了介面隔離原則。胖介面，導致很多類其實都不需要重寫方法，但是不得不繼承。實際工作中，我們可以將胖介面拆分，這樣狀態子類只需要實現自己需要的介面就可以了。

今天這裡還有一種特別的解決方案，也可以很巧妙的解決這個問題。

第一步：定義環境上下文類

觀察一下，這次的環境上下文類和方案二的有什麼區別？

對每一個狀態進行的強轉。這樣做的優點後面就可以看出來了

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 訂單上下文
 */
public class OrderContext {

    /**在上下文類中記錄訂單狀態*/
    private IOrderStatus orderStatus;

    public OrderContext() {
        System.out.println("開始購物");
        // 最開始是待付款狀態
        this.orderStatus = new Pending();
    }

    public void setOrderStatus(IOrderStatus orderStatus) {
        this.orderStatus = orderStatus;
    }


    /**
     * 去付款
     */
    public void toPay() {
        ((Pending)this.orderStatus).toPay(this);
    }

    /**
     * 取消付款
     */
    public void toCancelPay() {
        ((Pending)this.orderStatus).toCancelPay(this);
    }

    /**
     * 取消付款
     */
    public void cancelPay() {
        ((CancelPay)this.orderStatus).cancelPay(this);
    }

    /**
     * 去發貨
     */
    public void toSendProduct() {
        ((WaitOut)this.orderStatus).toSendProduct(this);
    }

    /**
     * 申請退款
     */
    public void toRefunds() {
        ((Confirm)this.orderStatus).toRefunds(this);
    }

    /**
     * 已退款
     */
    public void refunded() {
        ((Refunds)this.orderStatus).refunded(this);
    }

    public void toReceiveProduct() {
        ((WaitReceive)this.orderStatus).toReceiveProduct(this);
    }

    /**
     * 點選確認收貨按鈕
     */
    public void toConfirmReceived() {
        ((Confirm)this.orderStatus).toConfirmReceived(this);
    }

    /**
     * 去評價訂單
     */
    public void toOrderEvaluation() {
        ((OrderEvaluation)this.orderStatus).toOrderEvaluation(this);
    }

    /**
     * 已完成
     */
    public void finish() {
        ((Finish)this.orderStatus).finish(this);
    }
}

第二步：定義抽象狀態類

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 訂單狀態
 */
public interface IOrderStatus {

}

抽象狀態類裡面並沒有方法

第三步：定義具體狀態實現

待付款

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 待付款
 */
public class Pending implements IOrderStatus {
    public Pending() {
        System.out.println("當前狀態::待付款");

    }

    public void toPay(OrderContext context) {
        System.out.println("付款完成了, 待出庫");
        context.setOrderStatus(new WaitOut());
    }

    /*
     * 取消付款
     */
    public void toCancelPay(OrderContext context) {
        System.out.println("不想要了, 要取消付款");
        context.setOrderStatus(new CancelPay());
    }

}

待出庫

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 待出庫
 */
public class WaitOut implements IOrderStatus {

    public WaitOut() {
        System.out.println("當前狀態::待出庫");
    }


    /*
     * 退貨退款
     */
    public void toRefunds(OrderContext context) {
        System.out.println("不想要了, 申請退貨退款");
        context.setOrderStatus(new Refunds());
    }

    /**
     * 去發貨
     * @param context
     */
    public void toSendProduct(OrderContext context) {
        System.out.println("出庫完成, 待收貨");
        context.setOrderStatus(new WaitReceive());
    }
}

待收貨

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 待收貨
 */
public class WaitReceive implements IOrderStatus {

    public WaitReceive() {
        System.out.println("當前狀態 :: 待收貨");
    }

    /*
     * 退貨退款
     */
    public void refunds(OrderContext context) {
        System.out.println("申請退貨");
        context.setOrderStatus(new Refunds());
    }

    /**
     * 去收穫
     * @param context
     */
    public void toReceiveProduct(OrderContext context) {
        System.out.println("執行收貨邏輯, 完成收貨操作");
        context.setOrderStatus(new Confirm());

    }
}

確認收貨

package com.lxl.www.designPatterns.statePattern.order3;

public class Confirm implements IOrderStatus {

    public Confirm() {
        System.out.println("當前狀態 :: 確認收貨");
    }

    public void toRefunds(OrderContext context) {
        System.out.println("不想要了, 想退款");
        context.setOrderStatus(new Refunds());
    }


    public void toConfirmReceived(OrderContext context) {
        System.out.println("執行確認收貨邏輯");
        context.setOrderStatus(new OrderEvaluation());
    }
}

訂單評價

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 訂單評價
 */
public class OrderEvaluation implements IOrderStatus {

    public OrderEvaluation() {
        System.out.println("當前狀態 :: 訂單待評價");
    }

    public void toOrderEvaluation(OrderContext context) {
        System.out.println("訂單評價完了");
        context.setOrderStatus(new Finish());
    }
}

訂單完成

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 訂單完成
 */
public class Finish implements IOrderStatus {

    public void finish(OrderContext context) {
        System.out.println("訂單完成");
    }
}

取消付款

package com.lxl.www.designPatterns.statePattern.order3;

/**
 * 取消付款
 */
public class CancelPay implements IOrderStatus {


    /*
     * 取消付款
     */
    public void cancelPay(OrderContext context) {
        System.out.println("執行取消付款邏輯");
        context.setOrderStatus(new Finish());
    }

}

退貨退款

package com.lxl.www.designPatterns.statePattern.order3;

public class Refunds implements IOrderStatus {

    public Refunds() {
        System.out.println("當前狀態 :: 退貨退款");
    }


    public void refunded(OrderContext context) {
        System.out.println("完成退款");
        context.setOrderStatus(new Finish());
    }
}

第四步：客戶端呼叫

package com.lxl.www.designPatterns.statePattern.order3;

public class OrderClient {
    public static void main(String[] args) {
        System.out.println("==========張三   開始下單==========");
        OrderContext o1 = new OrderContext();

        System.out.println("===========取消付款==============");
        o1.toCancelPay();
        o1.cancelPay();


        System.out.println("");
        System.out.println("");
        System.out.println("==========李四    開始下單  收貨後退款==========");
        OrderContext o2 = new OrderContext();

        System.out.println("===========付款==============");
        o2.toPay();

        System.out.println("===========發貨==============");
        o2.toSendProduct();
        System.out.println("===========收穫==============");
        o2.toReceiveProduct();
        System.out.println("===========退貨==============");
        o2.toRefunds();
        o2.refunded();
        System.out.println("===========完成==============");
        o2.finish();


        System.out.println();
        System.out.println();
        System.out.println("==========王五    開始下單走完全流程==========");
        OrderContext o3 = new OrderContext();

        System.out.println("===========付款==============");
        o3.toPay();

        System.out.println("===========出庫==============");
        o3.toSendProduct();

        System.out.println("===========收貨==============");
        o3.toReceiveProduct();

        System.out.println("===========確認收貨==============");
        o3.toConfirmReceived();

        System.out.println("===========訂單評價==============");
        o3.toOrderEvaluation();

        System.out.println("===========訂單完成==============");
        o3.finish();

    }
}

執行結果：

張三開始下單

開始購物

當前狀態::待付款

=取消付款====

不想要了, 要取消付款

執行取消付款邏輯

李四開始下單收貨後退款

開始購物

當前狀態::待付款

=付款

付款完成了, 待出庫

當前狀態::待出庫

=發貨

出庫完成, 待收貨

當前狀態 :: 待收貨

=收穫

執行收貨邏輯, 完成收貨操作

當前狀態 :: 確認收貨

=退貨

不想要了, 想退款

當前狀態 :: 退貨退款

完成退款

=完成====

訂單完成

王五開始下單走完全流程

開始購物

當前狀態::待付款

=付款

付款完成了, 待出庫

當前狀態::待出庫

=出庫

出庫完成, 待收貨

當前狀態 :: 待收貨

=收貨

執行收貨邏輯, 完成收貨操作

當前狀態 :: 確認收貨

=確認收貨

執行確認收貨邏輯

當前狀態 :: 訂單待評價

=訂單評價

訂單評價完了

=訂單完成

訂單完成

執行結果和方案二是一樣的

四、狀態設計模式的優缺點

優點：

結構清晰，避免了過多的switch…case或if…else語句的使用
程式碼有很強的可讀性。狀態模式將每個狀態的行為封裝到對應的一個類中
狀態類職責明確，有利於程式的擴充套件。通過定義新的子類很容易地增加新的狀態和轉換。
封裝性非常好，狀態變化放置到了類的內部來實現，外部呼叫不需要知道類內部如何實現狀態和行為的變換

缺點：

會產生很多類。每個狀態都要一個對應的類，當狀態過多時會產生很多類，加大維

護難度
違背開閉原則：增加一個狀態，除了要增加狀態子類，還需要修改原來的環境類。

五、應用場景

當一個事件或者物件有很多種狀態，狀態之間會相互轉換，對不同的狀態要求有不同的行為的時候，可以考慮使用狀態模式

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

六、注意事項

在行為受狀態約束的情況下可以使用狀態模式，使用時物件的狀態最好不要超過5個。因為狀態越多，邏輯越負責，後期維護成本越高。

七、狀態模式對六大原則的使用分析

單一職責原則：符合單一職責原則，一個狀態類只做一件事
裡式替換原則：父類出現的地方都可以使用子類替換。--- 狀態模式父類是抽象類或者介面。方案一重寫了父類的構造方法
依賴倒置原則：依賴於抽象，而不是依賴於具體。---符合
介面隔離原則：依賴於最小介面---方案二不符合
迪米特法則：最小知識原則-之和朋友交流，減少和朋友的溝通 --- 符合
開閉原則：對擴充套件開放，對修改關閉----增加狀態需要修改原來的環境類---不符合

《設計模式七》備忘錄、模板方法、狀態模式及設計模式設計總結
2020-04-20
設計模式
設計模式-狀態模式
2021-05-01
設計模式
設計模式：狀態模式
2019-01-27
設計模式
23種設計模式之 State模式（狀態模式）[C語言實現]
2012-11-14
設計模式C語言
23種設計模式之——動態代理模式
2021-01-04
設計模式
23種設計模式(二)---策略設計模式
2021-06-21
設計模式
23種設計模式(八)-原型設計模式
2021-07-11
設計模式原型
設計模式（十五）狀態模式
2019-01-22
設計模式
設計模式之——狀態模式
2020-11-11
設計模式
javascript設計模式狀態模式
2017-04-12
JavaScript設計模式
設計模式（六）：狀態模式
2016-01-08
設計模式
23種設計模式
2020-12-22
設計模式
23種設計模式之代理模式（靜態代理）
2020-07-19
設計模式
23種設計模式（四）- 模板方法設計模式
2021-06-23
設計模式
PHP 設計模式之狀態模式
2020-01-07
PHP設計模式
簡說設計模式——狀態模式
2019-05-26
設計模式
設計模式之狀態模式（State）
2021-09-09
設計模式
設計模式-狀態模式（State Pattern）
2018-09-05
設計模式
python設計模式狀態模式
2019-01-03
Python設計模式
設計模式20之狀態模式
2020-11-23
設計模式
極簡設計模式-狀態模式
2021-12-10
設計模式
GoLang設計模式14 - 狀態模式
2021-11-13
Golang設計模式
Python設計模式-狀態模式
2017-06-26
Python設計模式
Java設計模式之狀態模式
2016-11-30
Java設計模式
設計模式——20狀態模式（State）
2017-12-11
設計模式
設計模式系列之「狀態模式」
2017-12-02
設計模式
23種設計模式(四)-代理模式
2021-06-22
設計模式
23種設計模式（7）-代理模式
2018-02-07
設計模式
23種設計模式之策略模式
2015-04-05
設計模式
23種設計模式之命令模式
2015-04-05
設計模式
23種設計模式(六)-責任鏈設計模式
2021-06-25
設計模式
java 23種設計模式 /
2017-06-04
Java設計模式
23種java設計模式
2012-09-30
Java設計模式
設計模式第八講-狀態模式
2019-01-19
設計模式
設計模式漫談之狀態模式
2018-08-05
設計模式
python設計模式【9】-狀態模式
2020-11-27
Python設計模式
《Head First 設計模式》：狀態模式
2020-09-21
設計模式
C#設計模式之狀態模式
2018-06-03
C#設計模式

23種設計模式(七)-狀態設計模式

一. 什麼是狀態模式?

二. 狀態模式的結構

1. 環境類

2. State抽象狀態類

3. 具體狀態

4. Client客戶端

三. 狀態模式的應用例項

第一種： 狀態是一條線的實現邏輯

第一步：定義上下文環境類。

第二步： 定義狀態抽象類。

第三步：定義狀態具體類。

第四步： 定義客戶端類， 模擬下單的流程

第二種： 帶有取消付款和退貨退款狀態。

第一步： 定義上下文環境類。

第二步：定義抽象狀態類

第三步：定義具體狀態類。

第四步： 客戶端呼叫

第三種：完善方案二

第一步： 定義環境上下文類

第二步： 定義抽象狀態類

第三步： 定義具體狀態實現

第四步：客戶端呼叫

四、狀態設計模式的優缺點

優點：

缺點：

五、應用場景

六、注意事項

七、狀態模式對六大原則的使用分析

相關文章

第一種：狀態是一條線的實現邏輯

第二步：定義狀態抽象類。

第四步：定義客戶端類，模擬下單的流程

第二種：帶有取消付款和退貨退款狀態。

第一步：定義上下文環境類。

第四步：客戶端呼叫

第一步：定義環境上下文類

第二步：定義抽象狀態類

第三步：定義具體狀態實現