《图解HTTP》第十章、第十一章
540
2022-05-30
状态模式
策略模式和状态模式是双胞胎,在出生时才分开。你已经知道,策略模式是围绕可以互换的算法来创建成功业务的,然而,状态走的是更崇高的路,它通过改变对象内部的状态来帮助对象控制自己的行为。
定义状态模式
先看看定义:状态模式允许对象在内部状态改变时改变它的行为,对象看起来好像修改了它的类
例题
自动糖果售卖机,糖果机的控制器需要的工作流程如下图
从上面的状态图中可以找到所有的状态:
我们可以创建一个实例变量来持有目前的状态,然后定义每个状态的值:
1
2
3
4
5
6
7
//每个状态用不同的值表示
final static int SOLD_OUT=0;//售罄
final static int NO_QUARTER=1;//没有投币
final static int HAS_QUARTER=2;//已投币
final static int SOLD=3;//售出糖果
//实例变量持有当前状态,只要改变变量值状态也会随之改变
int state =SOLD_OUT;
现在,我们将所有系统中可以发生的动作整合起来:
“投入25分钱”,“退回25分钱”,“转动曲柄”,“发放糖果”
这些动作是糖果机的接口,这是你能对糖果机做的事情,
调用任何一个动作都会造成状态的转换,
发放糖果更多是糖果机的内部动作,机器自己调用自己。
我们创建一个类,它的作用就像是一个状态机,每一个动作,我们都创建了一个对应的方法,这些方法利用条件语句来决定在每个状态内什么行为是恰当的。比如对“投入25分钱”这个动作来说,我们可以把对应方法写成下面的样子:
1
2
3
4
5
6
7
8
9
10
11
12
13
public void insertQuarter(){
if(state==HAS_QUARTER){
//每个状态对应的行为
......
}else if(state==SOLD_OUT){
......
}else if(state ==SOLD){
......
}else if(state==NO_QUARTER){
state=HAS_QUARTER;//状态转换
......
}
}
初步代码
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
class GumballMachine{
final static int SOLD_OUT=0;
final static int NO_QUARTER=1;
final static int HAS_QUARTER=2;
final static int SOLD=3;
int state =SOLD_OUT;
int count =0;//存储糖果数量
public GumballMachine(int count){
this.count=count;
if(count>0){
state=NO_QUARTER;
}
}
//当有25分钱投入,就会执行这个方法
public void insertQuarter(){
if(state==HAS_QUARTER){
System.out.println("如果已投入过25分钱,我们就告诉顾客");
}else if(state==NO_QUARTER){
state=HAS_QUARTER;
System.out.println("如果是在“没有25分钱”的状态下,我们就接收25分钱," +"并将状态转换到“有25分钱”的状态");
}else if(state ==SOLD_OUT){
System.out.println("如果糖果已经售罄,我们就拒绝收钱");
}else if(state==SOLD){
System.out.println("如果顾客刚才买了糖果,就需要稍等一下,好让状态转换完毕。" +"恢复到“没有25分钱”的状态");
state=NO_QUARTER;
}
}
//如果顾客试着退回25分钱就执行这个方法
public void ejectQuarter(){
if(state==HAS_QUARTER){
System.out.println("如果有25分钱,我们就把钱退出来,回到“没有25分钱”的状态");
state=NO_QUARTER;
}else if(state==NO_QUARTER){
System.out.println("如果没有25分钱的话,当然不能退出25分钱");
}else if(state ==SOLD){
System.out.println("顾客已经转动曲柄就不能再退钱了,他已经拿到糖果了");
}else if(state==SOLD_OUT){
System.out.println("如果糖果售罄,就不能接受25分钱,当然也不可能退钱");
}
}
//顾客试着转动曲柄
public void turnCrank(){
if(state==SOLD){
System.out.println("别想骗过机器拿两次糖果");
}else if(state==NO_QUARTER){
System.out.println("我们需要先投入25分钱");
}else if(state ==SOLD_OUT){
System.out.println("我们不能给糖果,已经没有任何糖果了");
}else if(state==HAS_QUARTER){
System.out.println("成功,他们拿到糖果了," +"改变状态到“售出糖果”然后调用机器的disoense()方法");
state=SOLD;
dispense();
}
}
//调用此方法,发放糖果
public void dispense(){
if(state==SOLD){
System.out.println("我们正在“出售糖果”状态,给他们糖果");
count=count-1;
/*
我们在这里处理“糖果售罄”的情况,如果这是最后一个糖果,将机器的状态设置到“糖果售罄”否则就回到“没有25分钱”的状态
*/
if(count==0){
System.out.println();
state=SOLD_OUT;
}else{
state=NO_QUARTER;
}
}else if(state==SOLD_OUT){
System.out.println("这些都不应该发生,但是如果做了,就得到错误提示");
}else if(state ==HAS_QUARTER){
System.out.println("这些都不应该发生,但是如果做了,就得到错误提示");
}else if(state==NO_QUARTER){
System.out.println("这些都不应该发生,但是如果做了,就得到错误提示");
}
}
}
尽管程序完美运行,但还是躲不掉需求变更的命运
现在糖果公司要求:当曲柄被转动时,有10%的几率掉下来的是两个糖果。(氪金扭蛋)
再回看一下我们的初步代码,想要实现新的需求将会变得非常麻烦:
必须新增一个中奖的“赢家”状态。
必须在每一个方法添加新的判断条件来处理“赢家”状态。
转动把手的方法中还需要检查目前状态是否是“赢家”再决定切换到“赢家”状态行为还是正常出售行为。
在现有代码基础上做增加将会很麻烦,也不利与以后的维护,扩展性差。
回顾一下第一章的策略模式中的设计原则:
找出应用中可能需要变化之处,把他们独立出来
将状态独立出来,封装成一个类,都实现State接口,类图如下:
新的设计想法如下:
首先,我们定义一个State接口,在这个接口内,糖果机的每个动作都有一个对应的方法
然后为机器的每个状态实现状态类,这些类将负责在对应的状态下进行机器的行为
最后,我们要摆脱旧的条件代码,取而代之的方式是,将动作委托到状态类
代码
定义一个State接口
1
2
3
4
5
6
public interface State {
public void insertQuarter();//投币
public void ejectQuarter();//退币
public void turnCrank();//转动出货把手
public void dispense();//出售
}
为机器的每个状态实现状态类:
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
//未投币状态
public class NoQuarterState implements State {
GumballMachine gumballMachine;
public NoQuarterState(GumballMachine gumballMachine) {
this.gumballMachine=gumballMachine;
}
public void insertQuarter() {
System.out.println("你投入一枚硬币");
gumballMachine.setState(gumballMachine.getHasQuarterState());//状态转换为已投币状态
}
public void ejectQuarter() {
System.out.println("你未投币,无法退钱");
}
public void turnCrank() {
System.out.println("未投币,请先投币");
}
public void dispense() {
System.out.println("请先投币");
}
}
//已投币状态
public class HasQuarterState implements State {
Random randomWinner=new Random(System.currentTimeMillis());
GumballMachine gumballMachine;
public HasQuarterState(GumballMachine gumballMachine) {
this.gumballMachine=gumballMachine;
}
public void insertQuarter() {
System.out.println("已投币,无法再接收投币");
}
public void ejectQuarter() {
System.out.println("已退币");
gumballMachine.setState(gumballMachine.getNoQuarterState());
}
public void turnCrank() {
System.out.println("已转动把手,糖果出售中。。。。");
int winner=randomWinner.nextInt(10);//随机数生成,用以标记“赢家”状态
if((winner==0)&&(gumballMachine.getCount()>1))
gumballMachine.setState(gumballMachine.getWinnerState());
else
gumballMachine.setState(gumballMachine.getSoldState());
}
public void dispense() {
System.out.println("机器中已经没有糖果可以出售了!");
}
}
//出售状态
public class SoldState implements State {
GumballMachine gumballMachine;
public SoldState(GumballMachine gumballMachine) {
this.gumballMachine=gumballMachine;
}
public void insertQuarter() {
System.out.println("请等候,正在初始化机器中");
}
public void ejectQuarter() {
System.out.println("抱歉,您已转动把手获得了糖果,无法退币");
}
public void turnCrank() {
System.out.println("您重复转动把手,无法再获取更多糖果");
}
public void dispense() {
gumballMachine.releaseBall();//出货,糖果-1
if(gumballMachine.getCount()>0)
gumballMachine.setState(gumballMachine.getNoQuarterState());
else {
System.out.println("糖果已售完");
gumballMachine.setState(gumballMachine.getSoldOutState());
}
}
}
//售罄状态
public class SoldOutState implements State {
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine) {
this.gumballMachine=gumballMachine;
}
public void insertQuarter() {
System.out.println("此机器的糖果已售完,不接收投币");
}
public void ejectQuarter() {
System.out.println("未投币,退币失败");
}
public void turnCrank() {
System.out.println("糖果已售完,转动把手也不会有糖果出来的");
}
public void dispense() {
System.out.println("机器中已无糖果");
}
}
//赢家状态
public class WinnerState implements State {
GumballMachine gumballMachine;
public WinnerState(GumballMachine gumballMachine) {
this.gumballMachine=gumballMachine;
}
public void insertQuarter() {
System.out.println("请等候,正在初始化机器中");
}
public void ejectQuarter() {
System.out.println("抱歉,您已转动把手获得了糖果");
}
public void turnCrank() {
System.out.println("您重复转动把手,无法再获取更多糖果");
}
public void dispense() {
System.out.println("恭喜你成为幸运儿,你将额外获得一个免费糖果");
gumballMachine.releaseBall();//出货,糖果-1
if(gumballMachine.getCount()==0)
gumballMachine.setState(gumballMachine.getSoldOutState());
else {
gumballMachine.releaseBall();
if(gumballMachine.getCount()>0)
gumballMachine.setState(gumballMachine.getNoQuarterState());
else {
System.out.println("糖果已售完");
gumballMachine.setState(gumballMachine.getSoldOutState());
}
}
}
}
糖果机类:
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
public class GumballMachine {
State soldOutState;
State noQuarterState;
State hasQuarterState;
State soldState;
State winnerState;
State state=soldOutState;
int count=0;
public GumballMachine(int numberGumballs) {//初始化
soldOutState=new SoldOutState(this);
noQuarterState=new NoQuarterState(this);
hasQuarterState=new HasQuarterState(this);
soldState=new SoldState(this);
winnerState=new WinnerState(this);
this.count=numberGumballs;
if(numberGumballs>0)
state=noQuarterState;//先判断条件再改变状态
}
//将动作委托到状态类
public void insterQuarter() {
state.insertQuarter();
}
public void ejectQuarter() {
state.ejectQuarter();
}
public void turnCrank() {
state.turnCrank();
state.dispense();
}
//获取当前状态
public State getHasQuarterState() {
return hasQuarterState;
}
//改变状态
public void setState(State state) {
this.state=state;
}
public void releaseBall() {
System.out.println("糖果从出口售出");
if(count!=0)
count-=1;
}
public State getSoldOutState() {
return soldOutState;
}
public State getNoQuarterState() {
return noQuarterState;
}
public State getSoldState() {
return soldState;
}
//获取糖果机中糖果数量
public int getCount() {
return count;
}
public State getWinnerState() {
return winnerState;
}
public String toString() {
// TODO 自动生成的方法存根
String s="剩余糖果:"+count;
return s;
}
}
以上就是用状态模式实现的,仔细观察你会发现状态模式其实和策略模式很像,来看看状态模式的类图:
状态模式的类图其实和策略模式完全一样!
状态模式与策略模式
这两个模式的差别在于它们的“意图”
以状态模式而言,我们将一群行为封装在状态对象中,context的行为随时可委托到那些状态对象中的一个,随着时间而流逝,当前状态在状态对象集合中游走改变,以反映出context内部的状态,因此,context的行为也会跟着改变,但是context的客户对于状态对象了解不多,甚至根本是浑然不觉。
以策略模式而言,客户通常主动指定Context所要组合的策略对象时哪一个。现在,固然策略模式让我们具有弹性,能够在运行时改变策略,但对于某个context对象来说,通常都只有一个最适当的策略对象。
一般的,我们把策略模式想成是除了继承之外的一种弹性替代方案,如果你使用继承定义了一个类的行为,你将被这个行为困住,是指要修改它都很难,有了策略模式,你可以通过组合不同的对象来改变行为。
我们把状态模式想成是不用在context中放置许多条件判断的替代方案,通过将行为包装进状态对象中,你可以通过在context内简单地改变状态对象来改变context的行为。
模式区分
状态模式:封装基于状态的行为,并将行为委托到当前状态
策略模式:将可以互换的行为封装起来。然后使用委托的方法,觉得使用哪一个行为
模板方法模式:由子类决定如何实现算法中的某些步骤
要点
(1)状态模式允许一个对象基于内部状态而拥有不同的行为。
(2)和程序状态机(PSM)不同,状态模式用类来表示状态。
(3)Context会将行为委托给当前状态对象。
(4)通过将每一个状态封装进一个类,我们把以后需要做的任何改变局部化了。
(5)状态模式和策略模式有相同的类图,但是他们的意图不同。
(6)策略模式通常会用行为或算法配置Context类。
(7)状态模式允许Context随着状态的改变而改变行为。
(8)状态转换可以有State类或Context类控制。
(9)使用状态模式通常会导致设计中类的数目大量增加。
(10)状态栏可以被多个Context实例共享。
版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。