状态模式

偷偷努力，悄无声息地变强，然后惊艳所有人！哈哈，小伙伴们又来学习啦~今天我将给大家介绍《状态模式》，这篇文章主要会讲到等等知识点，不知道大家对其都有多少了解，下面我们就一起来看一吧！当然，非常希望大家能多多评论，给出合理的建议，我们一起学习，一起进步！

什么是状态模式？

状态模式是一种行为模式，允许对象在其内部状态发生变化时改变其行为。该对象似乎会更改其类别。

什么时候使用它？

• 当您的对象的行为根据其当前状态而有所不同时，请使用状态模式。
• 当您想要实现表示有限自动机的系统时，请使用状态模式。

问题

我们正在开发自动售货机系统。这是显示自动售货机工作流程的图表。

如果你学过计算机科学，你可能会注意到它看起来像有限自动机（如果你不知道什么是 fa，不用担心，你不需要知道它来理解状态模式）。图中，圆圈代表状态，箭头代表状态交易。

无论如何，让我们开始编写我们的第一个版本的系统。

public class vendingmachine {

    // vending machine has four states
    final static int out_of_stock = 0;
    final static int idle = 1;
    final static int has_money = 2;
    final static int drink_sold = 3;

    // when vending machine is placed, it has no drink stocks
    int state = out_of_stock; // our initial state
    int stocks = 0;

    public vendingmachine(int stocks) {
        this.stocks = stocks;
        if (stocks > 0) {
            state = idle;
        }
    }

    public void insertmoney() {
        if (state == out_of_stock) {
            system.out.println("error: drink is out of stock");
        } else if (state == idle) {
            system.out.println("success: you inserted money");
            state = has_money;
        } else if (state == has_money) {
            system.out.println("error: you already inserted money, you can buy now");
        } else if (state == drink_sold) {
            system.out.println("error: please wait, we're dispensing you a drink that you bought");
        }
    }

    public void pressbuybutton() {
        // if statements for each states
    }

    public void presscancelbutton() {
        // if statements for each states
    }

    public void dispensedrink() {
        // if statements for each states
    }

    public void refill() {
        // if statements for each states
    }
}

你能发现问题吗？

• 这段代码违反了开闭原则。
• 此代码违反了单一责任原则。
• 此代码没有封装变化的内容。
• 状态转换并不显式，它们被放置在条件语句下。
• 如果添加其他状态或状态转换，可能会导致已经工作的代码出现错误。

解决方案

那么，我们如何解决这些问题呢？我们将把每个状态变成一个对象，然后实现表示从该特定状态（对象）进行状态转换的方法。

1. 客户
   客户端与自动售货机交互。

2. 自动售货机
   这个类拥有多个状态。通过引入state接口，依赖于接口而不是实现。

3. 状态
   为所有concretestate提供通用接口。

4. 具体状态
   每个状态事务根据状态有不同的行为。例如，idle 类中定义的 insertmoney 方法和 outofstock 状态下的方法的行为不同。

现在，vendingmachine 中的许多 if 语句被删除，并且状态转换是显式的（您将在实现中看到这一点）。

结构

这个结构让你想起另一种模式吗？是的，这个类图基本上与策略模式相同，但它们的意图不同。我们稍后再讨论。

java实现

// declare all possible state transition methods
public interface state {
    void insertmoney();
    void pressbuybutton();
    void presscancelbutton();
    void dispensedrink();
    void refill(int stocks);
}

public class drinksold implements state {

    vendingmachine machine;

    public drinksold(vendingmachine machine) {
        this.machine = machine;
    }

    @override
    public void insertmoney() {
        system.out.println("error: no state transition occurs");
    }

    @override
    public void pressbuybutton() {
        system.out.println("error: no state transition occurs");
    }

    @override
    public void presscancelbutton() {
        system.out.println("error: no state transition occurs");
    }

    @override
    public void dispensedrink() {
        machine.customertakesdrink();
        if (machine.getstocks() > 0) {
            system.out.println("success: drinksold -> idle");
            machine.setstate(machine.getidle());
        } else {
            system.out.println("success: drinksold -> outofstock");
            machine.setstate(machine.getoutofstock());
        }
    }

    @override
    public void refill(int stocks) {
        system.out.println("error: no state transition occurs");
    }
}

我将跳过其他具体状态，因为它们很相似，但您可以在我的 github 存储库中查看它们（我的存储库的链接位于本博客末尾）。

public class vendingmachine {

    private state idle;
    private state hasmoney;
    private state drinksold;
    private state outofstock;

    private state currentstate;
    int stocks = 0;

    public vendingmachine(int stocks) {
        idle = new idle(this);
        hasmoney = new hasmoney(this);
        drinksold = new drinksold(this);
        outofstock = new outofstock(this);

        this.stocks = stocks;
        if (stocks > 0) {
            currentstate = idle;
        } else {
            currentstate = outofstock;
        }
    }

    // state transition methods, actual implementation is delegated to concrete states
    public void insertmoney() {
        currentstate.insertmoney();
    }

    public void pressbuybutton() {
        currentstate.pressbuybutton();
        currentstate.dispensedrink();
    }

    public void presscancelbutton() {
        currentstate.presscancelbutton();
    }

    public void refill(int stocks) {
        currentstate.refill(stocks);
    }

    // method to be used by concrete states to move one state to another
    public void setstate(state state) {
        currentstate = state;
    }

    // helper method used when dispensing a drink on drinksold state
    public void customertakesdrink() {
        if (stocks > 0) {
            system.out.println("customer grab a drink");
            stocks--;
        }
    }

    // getter for each state
    public state getidle() {
        return idle;
    }

    public state gethasmoney() {
        return hasmoney;
    }

    public state getdrinksold() {
        return drinksold;
    }

    public state getoutofstock() {
        return outofstock;
    }

    public int getstocks() {
        return stocks;
    }

    public void setstocks(int stocks) {
        this.stocks = stocks;
    }

    @override
    public string tostring() {
        return "vendingmachine {" +
                "currentstate: " + currentstate.getclass().getsimplename() +
                ", stocks: " + stocks +
                '}';
    }
}

public class vendingmachinetestdrive {

    public static void main(string[] args) {
        vendingmachine machine = new vendingmachine(2);

        system.out.println(machine);

        system.out.println("-- customer insert money and cancel the transaction --");
        machine.insertmoney();
        machine.presscancelbutton();

        system.out.println("-- customer insert money and buy a drink --");
        machine.insertmoney();
        machine.pressbuybutton();

        system.out.println(machine);

        system.out.println("-- customer insert money and buy a drink --");
        machine.insertmoney();
        machine.pressbuybutton();

        system.out.println(machine);

        system.out.println("-- customer insert money --");
        machine.insertmoney();

        system.out.println("-- owner is going to refill drinks --");
        machine.refill(2);
        system.out.println(machine);
    }
}

输出：

VendingMachine {currentState: Idle, stocks: 2}
-- Customer insert money and cancel the transaction --
SUCCESS: Idle -> HasMoney
SUCCESS: HasMoney -> Idle
-- Customer insert money and buy a drink --
SUCCESS: Idle -> HasMoney
SUCCESS: HasMoney -> DrinkSold
Customer grab a drink
SUCCESS: DrinkSold -> Idle
VendingMachine {currentState: Idle, stocks: 1}
-- Customer insert money and buy a drink --
SUCCESS: Idle -> HasMoney
SUCCESS: HasMoney -> DrinkSold
Customer grab a drink
SUCCESS: DrinkSold -> OutOfStock
VendingMachine {currentState: OutOfStock, stocks: 0}
-- Customer insert money --
ERROR: no state transition occurs
-- Owner is going to refill drinks --
SUCCESS: OutOfStock -> Idle
VendingMachine {currentState: Idle, stocks: 2}

陷阱

• 状态模式最终往往会拥有很多类，因为存在的类就会有尽可能多的类。如果某些状态几乎相同，您可以将它们组合在一起。这样，我们减少了重复代码，但违反了单一责任原则，请记住，当您使用状态模式时，它们是权衡的。
• 如果一个状态有多个可达状态，实现起来会比较复杂。

与策略模式的比较

• 它们都允许对象通过组合和委托来合并不同的行为。
• 在策略模式中，“客户端”在运行时更改对象的行为。另一方面，在状态模式中，“上下文”根据明确定义的状态转换方法来改变状态。

您可以在这里查看所有设计模式的实现。
github 存储库

本篇关于《状态模式》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！