[设计模式] 设计模式课程（十五）-- 状态模式

概述

• 属于行为型模式
• 对象需要根据自身当前的状态进行不同行为，状态数量多且状态相关的代码频繁变更
• 在一个对象的内部状态变化时改变其行为，使其看上去就像改变了自身所属的类一样
• 组件构建过程中，某些对象的状态经常面临变化，如何对这些变化进行有效的管理？同时又维持高层模块的稳定？“状态变化”模式为这一问题提供了一种解决方案
• 经典模式：State, Memento
• State模式：某些对象的状态如果改变，其行为也会随之变化，如文档处于只读状态，其支持的行为和读写状态支持的行为就可能完全不同
• 如何在运行时根据对象的状态来透明地更改对象的行为？而不会为对象操作和状态转化间引入紧耦合？
• 类似于Strategy模式，解决if-else带来的业务判断问题，未来有新状态怎么办？（多态，运行时改变）
• 先提出抽象基类，将状态有关的操作变成状态对象的虚函数，再设计不同状态对应的类
• 虚函数本质：运行时的 if-else
• 将所有与一个特定状态相关的行为放入一个State的子类对象，在状态切换时切换成相应的对象，但同时维持State接口，实现了具体操作与状态转换间的解耦
• 为不同状态引入不同对象使得状态转换变得更加明确，且可以保证不会出现状态不一致的情况，因为转换是原子性的（彻底转换过来或者不转换）
• 若State对象没有实例变量，那么上下文可以共享一个对象，从而节省对象开销
• 每个状态只关心自己的后继状态

场景

• 对象行为随状态改变而改变

结构

• 上下文类：保存对一个具体状态对象的引用，并将所有与该状态相关的工作委派给它
• 状态接口：声明特定于状态的方法
• 具体状态类：实现特定于状态的方法

示例1

state1.cpp

enum NetworkState
{
    Network_Open,
    Network_Close,
    Network_Connect,
};

class NetworkProcessor{
    
    NetworkState state;

public:
    
    void Operation1(){
        if (state == Network_Open){

            //**********
            state = Network_Close;
        }
        else if (state == Network_Close){

            //..........
            state = Network_Connect;
        }
        else if (state == Network_Connect){

            //$$$$$$$$$$
            state = Network_Open;
        }
    }

    public void Operation2(){

        if (state == Network_Open){
            
            //**********
            state = Network_Connect;
        }
        else if (state == Network_Close){

            //.....
            state = Network_Open;
        }
        else if (state == Network_Connect){

            //$$$$$$$$$$
            state = Network_Close;
        }
    
    }

    public void Operation3(){

    }
};

state2.cpp

class NetworkState{

public:
    NetworkState* pNext;
    virtual void Operation1()=0;
    virtual void Operation2()=0;
    virtual void Operation3()=0;

    virtual ~NetworkState(){}
};

class OpenState :public NetworkState{
    
    static NetworkState* m_instance;
public:
    static NetworkState* getInstance(){
        if (m_instance == nullptr) {
            m_instance = new OpenState();
        }
        return m_instance;
    }

    void Operation1(){
        
        //**********
        pNext = CloseState::getInstance();
    }
    
    void Operation2(){
        
        //..........
        pNext = ConnectState::getInstance();
    }
    
    void Operation3(){
        
        //$$$$$$$$$$
        pNext = OpenState::getInstance();
    }
    
};

class CloseState:public NetworkState{ }
//...

class NetworkProcessor{
    
    NetworkState* pState;
    
public:
    
    NetworkProcessor(NetworkState* pState){
        
        this->pState = pState;
    }
    
    void Operation1(){
        //...
        pState->Operation1();
        pState = pState->pNext;
        //...
    }
    
    void Operation2(){
        //...
        pState->Operation2();
        pState = pState->pNext;
        //...
    }
    
    void Operation3(){
        //...
        pState->Operation3();
        pState = pState->pNext;
        //...
    }

};

示例2

#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.
 */

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() << ".
";
    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.
";
  }
};

class ConcreteStateB : public State {
 public:
  void Handle1() override {
    std::cout << "ConcreteStateB handles request1.
";
  }
  void Handle2() override {
    std::cout << "ConcreteStateB handles request2.
";
    std::cout << "ConcreteStateB wants to change the state of the context.
";
    this->context_->TransitionTo(new ConcreteStateA);
  }
};

void ConcreteStateA::Handle1() {
  {
    std::cout << "ConcreteStateA handles request1.
";
    std::cout << "ConcreteStateA wants to change the state of the context.
";

    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;
}

示例3

public interface State {
       public void doAction(Context context);
}

public class StartState implements State {

       public void doAction(Context context) {
          System.out.println("Player is in start state");
          context.setState(this); 
       }

       public String toString(){
          return "Start State";
       }
    }

public class StopState implements State {

       public void doAction(Context context) {
          System.out.println("Player is in stop state");
          context.setState(this); 
       }

       public String toString(){
          return "Stop State";
       }
    }

public class Context {
       private State state;

       public Context(){
          state = null;
       }

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

       public State getState(){
          return state;
       }
    }

public class StatePatternDemo {
       public static void main(String[] args) {
          Context context = new Context();

          StartState startState = new StartState();
          startState.doAction(context);

          System.out.println(context.getState().toString());

          StopState stopState = new StopState();
          stopState.doAction(context);

          System.out.println(context.getState().toString());
       }
    }

Player is in start state
Start State
Player is in stop state
Stop State

参考 

https://refactoringguru.cn/design-patterns/state