设计模式探秘-23-状态模式

状态模式的学习与实践

模式定义

当一个对象内在状态改变时允许其改变行为,该对象看起来像改变了其类。状态模式的核心是封装,状态的变化引起了行为的变更,从外部看起来好像这个对象对应的类改变了一样。

类图

  1. State 抽象状态角色 接口或抽象类,负责对象状态定义,并且封装环境角色已实现状态切换。
  2. ConcreteState 具体状态角色 每一个具体状态必须完成两个职责:本状态的行为管理以及趋向状态处理,即本状态要做什么,以及本状态如何过渡到其他状态。
  3. Context 环境角色 定义客户端需要的接口,并且负责具体状态的切换。

环境角色的约定:

  1. 状态对象声明为静态常量。
  2. 环境角色具有状态抽象角色定义的所有行为。

优点

  1. 结构清晰
  2. 遵循设计原则 很好的体现了开闭原则和单一职责原则
  3. 封装性好

缺点

子类会有太多。

使用场景

  1. 行为随状态而改变的场景
  2. 条件、分支判断语句的替代者

注意事项

状态模式适用于当某个对象在它的状态发生改变时,行为随着发生比较大的变化,即行为受状态约束的情况下可以使用状态模式。使用是对象的状态最好不要超过5个。

扩展

实践

简单实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#include <iostream>

using namespace std;

//状态模式
class State;
class Context;
class ConcreteStateA;
class ConcreteStateB;

class State
{
public:
State()
{
;
}
virtual ~State()
{
;
}
virtual void OperationInterface(Context *) = 0;
virtual void OperationChangeState(Context *) = 0;
protected:
bool ChangeState(Context *con, State *st);
};


void State::OperationInterface(Context *con)
{
cout<<"State::.."<<endl;
}

class ConcreteStateA : public State
{
public:
ConcreteStateA()
{
;
}
virtual ~ConcreteStateA()
{
;
}
virtual void OperationInterface(Context *con)
{
cout<<"ConcreteStateA::OperationInterface..."<<endl;
}
virtual void OperationChangeState(Context *con);
};

class ConcreteStateB : public State
{
public:
ConcreteStateB()
{
;
}
virtual ~ConcreteStateB()
{
;
}
virtual void OperationInterface(Context *con)
{
cout<<"ConcreteStateB::OperationInterface..."<<endl;
}
virtual void OperationChangeState(Context *con)
{
OperationInterface(con);
ChangeState(con, new ConcreteStateA());
}
};

class Context
{
public:
Context()
{
;
}
Context(State *state)
{
m_State = state;
}
~Context()
{
delete m_State;
}
void OperationInterface()
{
m_State->OperationInterface(this);
}
void OperationChangeState()
{
m_State->OperationChangeState(this);
}
bool ChangeState(State *state)
{
m_State = state;
return true;
}
private:
State *m_State;

friend class State;
};

bool State::ChangeState(Context *con, State *st)
{
con->ChangeState(st);
}

void ConcreteStateA::OperationChangeState(Context *con)
{
OperationInterface(con);
ChangeState(con, new ConcreteStateB());
}

int main()
{
State *st = new ConcreteStateA();
Context *con = new Context(st);
con->OperationChangeState();
con->OperationChangeState();
con->OperationChangeState();
con->OperationChangeState();
con->OperationChangeState();
con->OperationChangeState();

return 0;
}

参考资料

  1. 设计模式之禅
  2. GoF+23种设计模式解析