设计模式之状态模式

一、模式动机

　　在很多情况下，一个对象的行为取决于一个或多个动态变化的属性，这样的属性叫做状态，这样的对象叫做有状态的对象，对象的状态是从事先定义好的一系列值中取出的。当一个这样的对象与外部事件产生互动时，其内部状态就会改变，从而使得系统的行为也随之发生变化。

二、模式定义

　　状态模式（State Pattern）允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。UML类图如下:　　　　　
状态模式包含如下角色
● Context: 上下文类
● State: 抽象状态类
● ConcreteState: 具体状态类

三、模式示例

　　万能糖果公司希望糖果机如下图一样工作。

C++代码实现

State.h

#ifndef STATE_H
#define STATE_H

class GumballMachine;
//抽象状态类
class State
{
public:
    virtual void InsertQuarter() = 0;
    virtual void EjectQuarter() = 0;
    virtual void TurnCrank() = 0;
    virtual void Dispense() = 0;
};

/*具体状态类*/
class NoQuarterState : public State
{
public:
    NoQuarterState(GumballMachine *gumballMachine);
    void InsertQuarter();
    void EjectQuarter();
    void TurnCrank();
    void Dispense();

private:
    GumballMachine* gumballMachine;
};

class HasQuarterState : public State
{
public:
    HasQuarterState(GumballMachine* gumballMachine);
    void InsertQuarter();
    void EjectQuarter();
    void TurnCrank();
    void Dispense();

private:
    GumballMachine* gumballMachine;
};

class SoldState : public State
{
public:
    SoldState(GumballMachine* gumballMachine);
    void InsertQuarter();
    void EjectQuarter();
    void TurnCrank();
    void Dispense();

private:
    GumballMachine* gumballMachine;
};

class SoldOutState : public State
{
public:
    SoldOutState(GumballMachine* gumballMachine);
    void InsertQuarter();
    void EjectQuarter();
    void TurnCrank();
    void Dispense();

private:
    GumballMachine* gumballMachine;
};
#endif

State.cpp

#include <iostream>
#include "GumballMachine.h"
using namespace std;

NoQuarterState::NoQuarterState(GumballMachine* gumballMachine)
{
    this->gumballMachine = gumballMachine;
}
void NoQuarterState::InsertQuarter()
{
    cout << "You inserted a quarter" << endl;
    gumballMachine->SetState(gumballMachine->GetHasQuarterState());
}
void NoQuarterState::EjectQuarter()
{
    cout << "You haven't inserted a quarter" << endl;
}
void NoQuarterState::TurnCrank()
{
    cout << "You turned, but there's no quarter" << endl;
}
void NoQuarterState::Dispense()
{
    cout << "You need to pay first" << endl;
}


HasQuarterState::HasQuarterState(GumballMachine* gumballMachine)
{
    this->gumballMachine = gumballMachine;
}
void HasQuarterState::InsertQuarter()
{
    cout << "You can't insert another quarter" << endl;

}
void HasQuarterState::EjectQuarter()
{
    cout << "Quarter returned" << endl;
    gumballMachine->SetState(gumballMachine->GetNoQuarterState());
}
void HasQuarterState::TurnCrank()
{
    cout << "You turned..." << endl;
    gumballMachine->SetState(gumballMachine->GetSoldState());
}
void HasQuarterState::Dispense()
{
    cout << "No gumball dispensed" << endl;
}

SoldState::SoldState(GumballMachine* gumballMachine)
{
    this->gumballMachine = gumballMachine;
}
void SoldState::InsertQuarter()
{
    cout << "Please wait, we're already giving you a gumball" << endl;
}
void SoldState::EjectQuarter()
{
    cout << "Sorry, you already turned the crank" << endl;
}
void SoldState::TurnCrank()
{
    cout << "Turning twice doesn't get you another gumball" << endl;
}
void SoldState::Dispense()
{
    gumballMachine->ReleaseBall();
    if (gumballMachine->GetCount() > 0)
    {
        gumballMachine->SetState(gumballMachine->GetNoQuarterState());
    }
    else
    {
        gumballMachine->SetState(gumballMachine->GetSoldOutState());
    }
}


SoldOutState::SoldOutState(GumballMachine* gumballMachine)
{
    this->gumballMachine = gumballMachine;
}
void SoldOutState::InsertQuarter()
{
    cout << "You can't insert a quarter, the machine is sold out" << endl;
}
void SoldOutState::EjectQuarter()
{
    cout << "You can't eject, you haven't inserted a quarter yet" << endl;
}
void SoldOutState::TurnCrank()
{
    cout << "You turned, but there  are no gumballs" << endl;
}
void SoldOutState::Dispense()
{
    cout << "No gumball dispensed" << endl;
}

GumballMachine.h

#ifndef GUMBALL_MACHINE_H
#define GUMBALL_MACHINE_H
class State;
class GumballMachine
{
public:
    GumballMachine(int numberGumballs);
    void InsertQuarter();
    void EjectQuarter();
    void TurnCrank();
    State* GetHasQuarterState();
    State* GetNoQuarterState();
    State* GetSoldState();
    State* GetSoldOutState();
    void SetState(State* state);
    int GetCount()
    {
        return count;
    }
    void ReleaseBall()
    {
        if (count != 0)
        {
            count--;
        }
    }
private:
    State* state;
    State* soldOutState;
    State* noQuarterState;
    State* hasQuarterState;
    State* soldState;
    int count = 0;
};
#endif

GumballMachine.cpp

#include "GumballMachine.h"
#include "State.h"

GumballMachine::GumballMachine(int numberGumballs)
{
    soldOutState = new  SoldOutState(this);
    noQuarterState = new NoQuarterState(this);
    hasQuarterState = new HasQuarterState(this);
    soldState = new SoldState(this);
    count = numberGumballs;
    if (count > 0)
    {
        state = noQuarterState;
    }
}

void GumballMachine::InsertQuarter()
{
    state->InsertQuarter();
}

void GumballMachine::EjectQuarter()
{
    state->EjectQuarter();
}

void GumballMachine::TurnCrank()
{
    state->TurnCrank();
    state->Dispense();
}

State* GumballMachine::GetHasQuarterState()
{
    return hasQuarterState;
}

State* GumballMachine::GetNoQuarterState()
{
    return noQuarterState;
}

State* GumballMachine::GetSoldState()
{
    return soldState;
}

State* GumballMachine::GetSoldOutState()
{
    return soldOutState;
}

void GumballMachine::SetState(State* state)
{
    this->state = state;
}

main.cpp

#include "stdlib.h"
#include "GumballMachine.h"

int _tmain(int argc, _TCHAR* argv[])
{
    GumballMachine gumballMachine = GumballMachine(2);
    gumballMachine.InsertQuarter();
    gumballMachine.TurnCrank();
    gumballMachine.InsertQuarter();
    gumballMachine.TurnCrank();
    gumballMachine.InsertQuarter();
    gumballMachine.TurnCrank();

    system("pause");
    return 0;
}

运行结果：

四、分析总结

　　状态模式的关键是引入了一个抽象类来专门表示对象的状态，这个类我们叫做抽象状态类，而对象的每一种具体状态类都继承了该类，并在不同具体状态类中实现了不同状态的行为，包括各种状态之间的转换。这使得环境类对象在其内部状态改变时可以改变它的行为，对象看起来似乎修改了它的类，而实际上是由于切换到不同的具体状态类实现的。一句话：将状态封装成为独立的类，Context会将行为委托到代表当前状态的对象。
　　策略模式通常会用行为或算法来配置Context类，状态模式允许Context随着状态的改变而改变行为。

优点

1. 封装了转换规则。
2. 枚举可能的状态，在枚举状态之前需要确定状态种类。
3. 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
4. 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
5. 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

缺点

1. 状态模式的使用必然会增加系统类和对象的个数。
2. 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
3. 状态模式对“开闭原则”的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。