设计模式之状态模式

最新推荐文章于 2022-08-06 15:26:38 发布

原创最新推荐文章于 2022-08-06 15:26:38 发布 · 649 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#状态模式 #设计模式 #state

Head First设计模式(C++) 专栏收录该内容

16 篇文章

订阅专栏

本文详细介绍了状态模式的概念、原理及其实现方式，通过一个具体的糖果机案例演示了如何使用状态模式来实现对象行为的变化，适用于软件设计模式的学习者。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、模式动机

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

二、模式定义

　　状态模式（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随着状态的改变而改变行为。

优点

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

缺点

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