3.7 状态 State

一时失言乱红尘 2022-12-25 15:56 11阅读 0赞

**专业描述**  
状态模式是一种行为设计模式， 让你能在一个对象的内部状态变化时改变其行为， 使其看上去就像改变了自身所属的类一样。

**真实世界类比**  
智能手机的按键和开关会根据设备当前状态完成不同行为：

*  当手机处于解锁状态时， 按下按键将执行各种功能。
 *  当手机处于锁定状态时， 按下任何按键都将解锁屏幕。
 *  当手机电量不足时， 按下任何按键都将显示充电页面。

**状态模式结构**  
![在这里插入图片描述][20201202174552692.png_pic_center]

1.  **上下文 （Context）** 保存了对于一个具体状态对象的引用， 并会将所有与该状态相关的工作委派给它。 上下文通过状态接口与状态对象交互， 且会提供一个设置器用于传递新的状态对象。
2.  **状态 （State）** 接口会声明特定于状态的方法。 这些方法应能被其他所有具体状态所理解， 因为你不希望某些状态所拥有的方法永远不会被调用。
3.  **具体状态 （Concrete States）** 会自行实现特定于状态的方法。 为了避免多个状态中包含相似代码， 你可以提供一个封装有部分通用行为的中间抽象类。  
    状态对象可存储对于上下文对象的反向引用。 状态可以通过该引用从上下文处获取所需信息， 并且能触发状态转移。
4.  上下文和具体状态都可以设置上下文的下个状态， 并可通过替换连接到上下文的状态对象来完成实际的状态转换。

**状态模式适合应用场景**

*  如果对象需要根据自身当前状态进行不同行为， 同时状态的数量非常多且与状态相关的代码会频繁变更的话， 可使用状态模式。
 *  如果某个类需要根据成员变量的当前值改变自身行为， 从而需要使用大量的条件语句时， 可使用该模式。
 *  当相似状态和基于条件的状态机转换中存在许多重复代码时， 可使用状态模式。

**实现方式**

1.  确定哪些类是上下文。 它可能是包含依赖于状态的代码的已有类； 如果特定于状态的代码分散在多个类中， 那么它可能是一个新的类。
2.  声明状态接口。 虽然你可能会需要完全复制上下文中声明的所有方法， 但最好是仅把关注点放在那些可能包含特定于状态的行为的方法上。
3.  为每个实际状态创建一个继承于状态接口的类。 然后检查上下文中的方法并将与特定状态相关的所有代码抽取到新建的类中。

> 在将代码移动到状态类的过程中， 你可能会发现它依赖于上下文中的一些私有成员。 你可以采用以下几种变通方式：
> 
>  *  将这些成员变量或方法设为公有。
>  *  将需要抽取的上下文行为更改为上下文中的公有方法， 然后在状态类中调用。 这种方式简陋却便捷，你可以稍后再对其进行修补。
>  *  将状态类嵌套在上下文类中。 这种方式需要你所使用的编程语言支持嵌套类。

1.  在上下文类中添加一个状态接口类型的引用成员变量， 以及一个用于修改该成员变量值的公有设置器。
2.  再次检查上下文中的方法， 将空的条件语句替换为相应的状态对象方法。
3.  为切换上下文状态， 你需要创建某个状态类实例并将其传递给上下文。 你可以在上下文、 各种状态或客户端中完成这项工作。 无论在何处完成这项工作， 该类都将依赖于其所实例化的具体类。

C++算法示例：

#include <iostream>
    // #include <typeinfo>
    /** * The base State class declares methods that all Concrete State should * implement and also provides a backreference to the Context object, associated * with the State. This backreference can be used by States to transition the * Context to another State. * context 上下文 state 状态 */
    
    class Context;
    
    class State { 
      /** * @var Context */
     protected:
      Context *context_;
    
     public:
      virtual ~State() { 
      }
    
      void set_context(Context *context) { 
        this->context_ = context;
      }
    
      virtual void Handle1() = 0;
      virtual void Handle2() = 0;
    };
    
    /** * The Context defines the interface of interest to clients. It also maintains a * reference to an instance of a State subclass, which represents the current * state of the Context. */
    class Context { 
      /** * @var State A reference to the current state of the Context. */
     private:
      State *state_;
    
     public:
      Context(State *state) : state_(nullptr) { 
        this->TransitionTo(state);
      }
      ~Context() { 
        delete state_;
      }
      /** * The Context allows changing the State object at runtime. */
      void TransitionTo(State *state) { 
        std::cout << "Context: Transition to " << typeid(*state).name() << ".\n";
        if (this->state_ != nullptr)
          delete this->state_;
        this->state_ = state;
        this->state_->set_context(this);
      }
      /** * The Context delegates part of its behavior to the current State object. */
      void Request1() { 
        this->state_->Handle1();
      }
      void Request2() { 
        this->state_->Handle2();
      }
    };
    
    /** * Concrete States implement various behaviors, associated with a state of the * Context. */
    
    class ConcreteStateA : public State { 
     public:
      void Handle1() override;
    
      void Handle2() override { 
        std::cout << "ConcreteStateA handles request2.\n";
      }
    };
    
    class ConcreteStateB : public State { 
     public:
      void Handle1() override { 
        std::cout << "ConcreteStateB handles request1.\n";
      }
      void Handle2() override { 
        std::cout << "ConcreteStateB handles request2.\n";
        std::cout << "ConcreteStateB wants to change the state of the context.\n";
        this->context_->TransitionTo(new ConcreteStateA);
      }
    };
    
    void ConcreteStateA::Handle1() { 
      { 
        std::cout << "ConcreteStateA handles request1.\n";
        std::cout << "ConcreteStateA wants to change the state of the context.\n";
    
        this->context_->TransitionTo(new ConcreteStateB);
      }
    }
    
    /** * The client code. */
    void ClientCode() { 
      Context *context = new Context(new ConcreteStateA);
      context->Request1();
      context->Request2();
      delete context;
    }
    
    int main() { 
      ClientCode();
      return 0;
    }

output:

Context: Transition to 14ConcreteStateA.
    ConcreteStateA handles request1.
    ConcreteStateA wants to change the state of the context.
    Context: Transition to 14ConcreteStateB.
    ConcreteStateB handles request2.
    ConcreteStateB wants to change the state of the context.
    Context: Transition to 14ConcreteStateA.

[20201202174552692.png_pic_center]: /images/20221120/6346d49b65d649059d3dd7af763847b6.png