设计模式 - 状态模式与策略模式的区别

类图：

状态模式和策略模式的类图几乎一模一样。

策略模式：

其思想是针对一组算法，将每一种算法都封装到具有共同接口的独立的类中，不同的行为使用不同的算法，并且它们可以相互替换。它是直接依赖注入到Context类的参数进行选择策略，所以客户端必须事先知道策略,由它去指定环境(Context)类使用哪种策略(算法)。

状态模式：

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
每个状态子类需要包含环境类（Context），自己给自己的环境类切换状态来选择不同的行为，所以客户端不需要事先了解状态。

总结：

策略模式 需要由 客户端指定 Context选择哪种策略，所以客户端 需要 事先了解策略;
状态模式 是自己内部达到某种条件会自动切换 状态，所以客户端不需要了解状态，只需要调用状态方法。

例子:

状态模式:

//测试
public class StatePatternExample : MonoBehaviour
{
    void Start()
    {
        Context theContext = new Context();
        theContext.SetState(new ConcreteStateA(theContext));
        theContext.Request(5);
        theContext.Request(15);
        theContext.Request(25);
    }
}

//执行环境
public class Context
{
    State m_State = null;

    public void Request(int Value)
    {
        m_State.Handle(Value);
    }

    public void SetState(State theState)
    {
        Debug.Log("Context.SetState:" + theState);
        m_State = theState;
    }
}

// 状态的抽象基类
public abstract class State
{
    protected Context m_Context = null;

    public State(Context theContext)
    {
        m_Context = theContext;
    }
    public abstract void Handle(int Value);
}

// 状态A
public class ConcreteStateA : State
{
    public ConcreteStateA(Context theContext) : base(theContext)
    { }

    public override void Handle(int Value)
    {
        Debug.Log("ConcreteStateA.Handle");
        if (Value > 10)
            m_Context.SetState(new ConcreteStateB(m_Context));
    }

}

// 状态B
public class ConcreteStateB : State
{
    public ConcreteStateB(Context theContext) : base(theContext)
    { }

    public override void Handle(int Value)
    {
        Debug.Log("ConcreteStateB.Handle");
        if (Value > 20)
            m_Context.SetState(new ConcreteStateC(m_Context));
    }
}

策略模式:

//测试
public class StrategyPatternExample : MonoBehaviour
{
    void Start()
    {
        Context studentRecords = new Context();
        
        studentRecords.SetStrategy(new StrategyA());
        studentRecords.ExecuteAlgorithm();

        studentRecords.SetStrategy(new StrategyB());
        studentRecords.ExecuteAlgorithm();
    }
}


class Context
{
    private Strategy _strategy;

    public void SetStrategy(Strategy sortstrategy)
    {
        this._strategy = sortstrategy;
    }
    public void ExecuteAlgorithm()
    {
        _strategy.ExecuteAlgorithm();
    }
}

// 策略抽象类
public abstract class Strategy
{
    public abstract void ExecuteAlgorithm();
}

// 策略A
class StrategyA : Strategy
{
    public override void ExecuteAlgorithm()
    {
        Debug.Log("-------StrategyA------- ");
    }
}

// 策略B
class StrategyB : Strategy
{
    public override void ExecuteAlgorithm()
    {
        Debug.Log("-------StrategyB------ ");
    }
}