24种设计模式--状态模式【State Pattern】

By | 01月25日
Advertisement

  现在城市发展很快,百万级人口的城市一堆一堆的,那其中有两个东西的发明在城市的发展中起到非常重要的作用:一个是汽车,一个呢是...,猜猜看,是什么?是电梯!汽车让城市可以横向扩展,电梯让城市可以纵向延伸,向空中伸展。汽车对城市的发展我们就不说了,电梯,你想想看,如果没有电梯,每天你需要爬 10 层楼梯, 你是不是会崩溃掉?建筑师设计了一个没有电梯的建筑,那投资家肯定不愿意投资,那也是建筑师的耻辱呀,今天我们就用程序表现一下这个电梯是怎么运作的。

  我们每天都在乘电梯,那我们来看看电梯有哪些动作(映射到 Java 中就是有多少方法):开门、关门、运行、停止,就这四个动作,好,我们就用程序来实现一下电梯的动作,先看类图设计:

24种设计模式--状态模式【State Pattern】

  非常简单的类图,定义一个接口,然后是一个实现类,然后业务类 Client 就可以调用,并运行起来,简单也来看看我们的程序,先看接口:

 1 package com.pattern.state;
 2
 3 /**
 4  * 定义一个电梯的接口
 5  * @author http://www.cnblogs.com/initial-road/
 6  *
 7  */
 8 public interface ILift {
 9
10     // 首先电梯门开启动作
11     public void open();
12
13     // 电梯门有开启,那当然也就有关闭
14     public void close();
15
16     // 电梯要能上能下,跑起来
17     public void run();
18
19     // 电梯还要能停下来,停不下来那就扯淡了
20     public void stop();
21
22 }
23
24 // 然后看实现类:
25
26 package com.pattern.state;
27
28 /**
29  * 电梯的实现类
30  * @author http://www.cnblogs.com/initial-road/
31  *
32  */
33 public class Lift implements ILift {
34
35     // 电梯门关闭
36     public void close() {
37         System.out.println("电梯门关闭...");
38     }
39
40     // 电梯门开启
41     public void open() {
42         System.out.println("电梯门开启...");
43     }
44
45     // 电梯开始跑起来
46     public void run() {
47         System.out.println("电梯上下跑起来...");
48     }
49
50     // 电梯停止
51     public void stop() {
52         System.out.println("电梯停止了...");
53     }
54
55 }
56
57 // 电梯的开、关、跑、停都实现了,来看业务是怎么调用的:
58
59 package com.pattern.state;
60
61 /**
62  * 模拟电梯的动作
63  * @author http://www.cnblogs.com/initial-road/
64  *
65  */
66 public class Client {
67
68     public static void main(String[] args) {
69         ILift lift = new Lift();
70         // 首先是电梯门开启,人进去
71         lift.open();
72
73         // 然后电梯门关闭
74         lift.close();
75
76         // 再然后,电梯跑起来,向上或者向下
77         lift.run();
78
79         // 最后到达目的地,电梯停下来
80         lift.stop();
81     }
82
83 }

  太简单的程序了,是个程序员都会写这个程序,这么简单的程序还拿出来 show,是不是太小看我们的智商了?!非也,非也,我们继续往下分析,这个程序有什么问题,你想呀电梯门可以打开,但不是随时都可以开,是有前提条件的的,你不可能电梯在运行的时候突然开门吧?!电梯也不会出现停止了但是不开门的情况吧?!那要是有也是事故嘛,再仔细想想,电梯的这四个动作的执行都是有前置条件,具体点说在特定状态下才能做特定事,那我们来分析一下电梯有什么那些特定状态:

  门敞状态---按了电梯上下按钮,电梯门开,这中间有 5 秒的时间(当然你也可以用身体挡住电梯门,那就不是 5 秒了),那就是门敞状态;在这个状态下电梯只能做的动作是关门动作,做别的动作?那就危险喽

  门闭状态---电梯门关闭了,在这个状态下,可以进行的动作是:开门(我不想坐电梯了)、停止(忘记按路层号了)、运行

  运行状态---电梯正在跑,上下窜,在这个状态下,电梯只能做的是停止;

  停止状态---电梯停止不动,在这个状态下,电梯有两个可选动作:继续运行和开门动作;

  我们用一张表来表示电梯状态和动作之间的关系:

24种设计模式--状态模式【State Pattern】

  看到这张表后,我们才发觉,哦~~,我们的程序做的很不严谨,好,我们来修改一下,先看类图:

24种设计模式--状态模式【State Pattern】

                      增加了状态的类图

  在接口中定义了四个常量,分别表示电梯的四个状态:门敞状态、关闭状态、运行状态、停止状态,然后在实现类中电梯的每一次动作发生都要对状态进行判断,判断是否运行执行,也就是动作的执行是否符合业务逻辑,实现类中的四个私有方法是仅仅实现电梯的动作,没有任何的前置条件,因此这四个方法是不能为外部类调用的,设置为私有方法。我们先看接口的改变:

  1 package com.pattern.state.advance;
  2
  3 /**
  4  * 定义电梯的接口
  5  * @author http://www.cnblogs.com/initial-road/
  6  *
  7  */
  8 public interface ILift {
  9
 10     // 电梯的四个状态
 11     public final static int OPENING_STATE = 1;
 12     public final static int CLOSEING_STATE = 2;
 13     public final static int RUNNING_STATE = 3;
 14     public final static int STOPPING_STATE = 4;
 15
 16     // 设置电梯的状态
 17     public void setState(int state);
 18
 19     // 首先电梯门开启动作
 20     public void open();
 21
 22     // 电梯门有开启,那当然也就有关闭
 23     public void close();
 24
 25     // 电梯要能上能下,跑起来
 26     public void run();
 27
 28     // 电梯还要能停下来,停不下来那就扯淡了
 29     public void stop();
 30 }
 31
 32 // 增加了四个静态常量,增加了一个方法 setState,设置电梯的状态。我们再来看实现类是如何实现的:
 33
 34 package com.pattern.state.advance;
 35
 36 /**
 37  * 电梯的实现类
 38  * @author http://www.cnblogs.com/initial-road/
 39  *
 40  */
 41 public class Lift implements ILift {
 42     private int state;
 43
 44     // 电梯在什么状态下才能关闭
 45     public void close() {
 46         switch(this.state){
 47         case OPENING_STATE:    //如果是则可以开门,同时修改电梯状态
 48             this.closeWithoutLogic();
 49             this.setState(CLOSEING_STATE);
 50             break;
 51         case CLOSEING_STATE:    // 如果电梯就是关门状态,则什么都都不做
 52             // do nothing
 53             break;
 54         case RUNNING_STATE:        // 如果是正在运行,门本来就是关闭的,也说明都不做
 55             // do nothing
 56             break;
 57         case STOPPING_STATE:        // 如果是停止状态,门本来就是关闭,什么也不做
 58             // do nothing
 59             break;
 60         }
 61     }
 62
 63     // 电梯门开启
 64     public void open() {
 65         // 电梯在什么状态下才能开启
 66         switch(this.state){
 67         case OPENING_STATE:        // 如果已经在门敞状态,则什么都不做
 68             // do nothing
 69             break;
 70         case CLOSEING_STATE:    // 如果是电梯门关闭状态,则可以开启
 71             this.openWithoutLogic();
 72             this.setState(OPENING_STATE);
 73             break;
 74         case RUNNING_STATE:        // 正在运行状态,则不能开门,什么都不做
 75             // do nothing
 76             break;
 77         case STOPPING_STATE:    // 停止状态,当然要开门了
 78             this.openWithoutLogic();
 79             this.setState(OPENING_STATE);
 80             break;
 81         }
 82     }
 83
 84     // 电梯开始跑起来
 85     public void run() {
 86         // 电梯在什么状态才能运行
 87         switch(this.state){
 88         case OPENING_STATE:        // 如果已经在门敞状态,则不能运行,什么都不做
 89             // do nothing
 90             break;
 91         case CLOSEING_STATE:    // 如果是电梯关闭状态,则可以运行
 92             this.runWithoutLogic();
 93             this.setState(RUNNING_STATE);
 94             break;
 95         case RUNNING_STATE:
 96             // do nothing
 97             break;
 98         case STOPPING_STATE:
 99             this.runWithoutLogic();
100             this.setState(RUNNING_STATE);
101             break;
102         }
103     }
104
105     public void setState(int state) {
106         this.state = state;
107     }
108
109     // 电梯停止
110     public void stop() {
111         // 电梯在什么状态下才能停止
112         switch(this.state){
113         case OPENING_STATE:        // 如果已经在门敞状态,那肯定要先停下来,什么都不做
114             // do nothing
115             break;
116         case CLOSEING_STATE:    // 如果电梯是关闭状态,则当然可以停止了
117             this.stopWithoutLogic();
118             this.setState(CLOSEING_STATE);
119             break;
120         case RUNNING_STATE:        // 正在运行状态,有运行当然那也就有停止了
121             this.stopWithoutLogic();
122             this.setState(CLOSEING_STATE);
123             break;
124         case STOPPING_STATE:    // 停止状态,什么都不做
125             // do nothing
126             break;
127         }
128     }
129
130     // 纯粹的电梯关门,不考虑实际的逻辑
131     private void closeWithoutLogic(){
132         System.out.println("电梯门关闭...");
133     }
134
135     // 纯粹的电梯开门,不考虑任何条件
136     private void openWithoutLogic(){
137         System.out.println("电梯门开启...");
138     }
139
140     // 纯粹的运行,不考虑其他条件
141     private void runWithoutLogic(){
142         System.out.println("电梯上下跑起来了...");
143     }
144
145     // 单纯的停止,不考虑其他条件
146     private void stopWithoutLogic(){
147         System.out.println("电梯停止了...");
148     }
149 }
150
151 // 程序有点长,但是还是很简单的,就是在每一个接口定义的方法中使用 switch…case 来进行判断,是否运行指定的动作。我们来 Client 程序的变更:
152
153 package com.pattern.state.advance;
154
155 /**
156  * 模拟电梯的动作
157  * @author http://www.cnblogs.com/initial-road/
158  *
159  */
160 public class Client {
161
162     public static void main(String[] args) {
163         ILift lift = new Lift();
164
165         // 电梯的初始条件应该是停止状态
166         lift.setState(ILift.STOPPING_STATE);
167
168         // 首先是电梯门开启,人进去
169         lift.open();
170
171         // 然后电梯门关闭
172         lift.close();
173
174         // 再然后,电梯跑起来,向上或者向下
175         lift.run();
176
177         // 最后到达目的地,电梯停下来
178         lift.stop();
179
180     }
181
182 }

  业务调用的方法中增加了电梯状态判断,电梯要开门不是随时都可以开的,必须满足了一定条件你才能开门,人才能走进去,我们设置电梯的起始是停止状态。

  我们来想一下,这段程序有什么问题,首先 Lift.java 这个文件有点长,长的原因是我们在程序中使用了大量的 switch…case 这样的判断(if…else 也是一样),程序中只要你有这样的判断就避免不了加长程序,同步的在业务比较复杂的情况下,程序体会更长,这个就不是一个很好的习惯了,较长的方法或者类的维护性比较差,毕竟程序是给人来阅读的;其次,扩展性非常的不好,大家来想想,电梯还有两个状态没有加,是什么?通电状态和断电状态,你要是在程序再增加这两个方法, 你看看 Open()、 Close()、 Run()、Stop()这四个方法都要增加判断条件,也就是说 switch 判断体中还要增加 case 项,也就说与开闭原则相违背了;再其次,我们来思考我们的业务,电梯在门敞开状态下就不能上下跑了吗?电梯有没有发生过只有运行没有停止状态呢(从 40 层直接坠到 1 层嘛)?电梯故障嘛,还有电梯在检修的时候,可以在 stop状态下不开门,这也是正常的业务需求呀,你想想看,如果加上这些判断条件,上面的程序有多少需要修改?虽然这些都是电梯的业务逻辑,但是一个类有且仅有一个原因引起类的变化,单一职责原则,看看我们的类,业务上的任务一个小小增加或改动都对我们的这个电梯类产生了修改,这是在项目开发上是有很大风险的。既然我们已经发现程序上有以上问题,我们怎么来修改呢?

  刚刚我们是从电梯的有哪些方法以及这些方法执行的条件去分析,现在我们换个角度来看问题,我们来想电梯在具有这些状态的时候,能够做什么事情,也就是说在电梯处于一个具体状态时,我们来思考这个状态是由什么动作触发而产生以及在这个状态下电梯还能做什么事情,举个例子来说,电梯在停止状态时,我们来思考两个问题:

  第一、这个停止状态时怎么来的,那当然是由于电梯执行了 stop 方法而来的;

  第二、在停止状态下,电梯还能做什么动作?继续运行?开门?那当然都可以了。

  我们再来分析其他三个状态,也都是一样的结果,我们只要实现电梯在一个状态下的两个任务模型就可以了:这个状态是如何产生的以及在这个状态下还能做什么其他动作(也就是这个状态怎么过渡到其他状态),既然我们以状态为参考模型,那我们就先定义电梯的状态接口,思考过后我们来看类图:

24种设计模式--状态模式【State Pattern】

                  以状态作为导向的类图

  在类图中,定义了一个 LiftState 抽象类,声明了一个受保护的类型 Context 变量,这个是串联我们各个状态的封装类,封装的目的很明显,就是电梯对象内部状态的变化不被调用类知晓,也就是迪米特法则了,我的类内部情节你知道越少越好,并且还定义了四个具体的实现类,承担的是状态的产生以及状态间的转换过渡,我们先来看 LiftState 程序:

 1 package com.pattern.state.advance2;
 2
 3 /**
 4  * 定义一个电梯的接口
 5  * @author http://www.cnblogs.com/initial-road/
 6  *
 7  */
 8 public abstract class LiftState {
 9
10     // 定义一个环境角色,也就是封装状态的变换引起的功能变化
11     protected Context context;
12
13     public void setContext(Context _context){
14         this.context = _context;
15     }
16
17     // 首先电梯门开启动作
18     public abstract void open();
19
20     // 电梯门有开启,那当然也就有关闭了
21
22     public abstract void close();
23     // 电梯要能上能下,跑起来
24     public abstract void run();
25
26     // 电梯还要能停下来,停不下来那就扯淡了
27     public abstract void stop();
28 }
29
30 // 抽象类比较简单,我们来先看一个具体的实现,门敞状态的实现类:
31
32 package com.pattern.state.advance2;
33
34 /**
35  * 在电梯门开启的状态下能做什么事情
36  * @author http://www.cnblogs.com/initial-road/
37  *
38  */
39 public class OpenningState extends LiftState {
40
41     // 开启当然可以关闭了,我就像测试一下电梯门开关功能
42     public void close() {
43         // 状态修改
44         super.context.setLiftState(Context.closeingState);
45         // 动作委托为CloseState来执行
46         super.context.getLiftState().close();
47     }
48
49     // 打开电梯门
50     public void open() {
51         System.out.println("电梯门开启...");
52     }
53
54     // 门开着电梯就想跑,这电梯,吓死你!
55     public void run() {
56         // do nothing;
57     }
58
59     // 开门还不停止?
60     public void stop() {
61         // do nothing;
62     }
63
64 }

  我来解释一下这个类的几个方法,Openning 状态是由 open()方法产生的,因此这个方法中有一个具体的业务逻辑,我们是用 print 来代替了;在Openning 状态下,电梯能过渡到其他什么状态呢?按照现在的定义的是只能过渡到 Closing 状态,因此我们在 Close()中定义了状态变更,同时把 Close 这个动作也委托了给 CloseState 类下的 Close 方法执行,这个可能不好理解,我们再看看 Context 类就可能好理解一点:

 1 package com.pattern.state.advance2;
 2
 3 public class Context {
 4     // 定义出所有的电梯状态
 5     public final static OpenningState openningState = new OpenningState();
 6     public final static CloseingState closeingState = new CloseingState();
 7     public final static RunningState runningState = new RunningState();
 8     public final static StoppingState stoppingState = new StoppingState();
 9
10     // 定义一个当前电梯状态
11     private LiftState liftState;
12
13     public LiftState getLiftState() {
14         return this.liftState;
15     }
16
17     public void setLiftState(LiftState liftState) {
18         this.liftState = liftState;
19         // 把当前的环境通知到各个实现类中
20         this.liftState.setContext(this);
21     }
22
23     public void open(){
24         this.liftState.open();
25     }
26
27     public void close(){
28         this.liftState.close();
29     }
30
31     public void run(){
32         this.liftState.run();
33     }
34
35     public void stop(){
36         this.liftState.stop();
37     }
38 }

  结合以上三个类,我们可以这样理解,Context 是一个环境角色,它的作用是串联各个状态的过渡,在LiftSate 抽象类中我们定义了并把这个环境角色聚合进来,并传递到了子类,也就是四个具体的实现类中自己根据环境来决定如何进行状态的过渡。我们把其他的三个具体实现类阅读完毕,下面是关闭状态:

  1 package com.pattern.state.advance2;
  2
  3 /**
  4  * 电梯门关闭以后,电梯可以做哪些事情
  5  * @author http://www.cnblogs.com/initial-road/
  6  *
  7  */
  8 public class CloseingState extends LiftState {
  9
 10     // 电梯门关闭,这是关闭状态要实现的动作
 11     public void close() {
 12         System.out.println("电梯门关闭...");
 13     }
 14
 15     // 电梯门关了再打开,逗你玩呢,那这个允许呀!
 16     public void open() {
 17         // 置为门敞状态
 18         super.context.setLiftState(Context.openningState);
 19         super.context.getLiftState().open();
 20     }
 21
 22     // 电梯门关了就跑,这是再正常不过了
 23     public void run() {
 24         // 设置为运行状态
 25         super.context.setLiftState(Context.runningState);
 26         super.context.getLiftState().run();
 27     }
 28
 29     // 电梯门关着,我就不按楼层
 30     public void stop() {
 31         super.context.setLiftState(Context.stoppingState);
 32         super.context.getLiftState().stop();
 33     }
 34
 35 }
 36
 37 // 下面是电梯的运行状态:
 38
 39 package com.pattern.state.advance2;
 40
 41 /**
 42  * 电梯在运行状态下能做哪些动作
 43  * @author http://www.cnblogs.com/initial-road/
 44  *
 45  */
 46 public class RunningState extends LiftState {
 47
 48     // 电梯门关闭?这是肯定了
 49     public void close() {
 50         // do nothing
 51     }
 52
 53     // 运行的时候开电梯门?你疯了!电梯不会给你打开的
 54     public void open() {
 55         // do nothing
 56     }
 57
 58     // 这是在运行状态下要实现的方法
 59     public void run() {
 60         System.out.println("电梯上下跑...");
 61     }
 62
 63     // 这个事绝对是合理的,光运行不停止还有谁敢做这个电梯?!估计只有上帝了
 64     public void stop() {
 65         // 环境设置为停止状态
 66         super.context.setLiftState(Context.stoppingState);
 67         super.context.getLiftState().stop();
 68     }
 69
 70 }
 71
 72 // 下面是停止状态:
 73
 74 package com.pattern.state.advance2;
 75
 76 /**
 77  * 在停止状态下能做什么事情
 78  * @author http://www.cnblogs.com/initial-road/
 79  *
 80  */
 81 public class StoppingState extends LiftState {
 82
 83     // 停止状态关门?电梯门本来就是关着的!
 84     public void close() {
 85         // do nothing
 86     }
 87
 88     // 停止状态,开门,那是要的!
 89     public void open() {
 90         super.context.setLiftState(Context.openningState);
 91         super.context.getLiftState().open();
 92     }
 93
 94     // 停止状态再跑起来,正常的很
 95     public void run() {
 96         super.context.setLiftState(Context.runningState);
 97         super.context.getLiftState();
 98     }
 99
100     // 停止状态是怎么发生的呢?当然是停止方法执行了
101     public void stop() {
102         System.out.println("电梯停止了...");
103     }
104
105 }
106
107 // 业务逻辑都已经实现了,我们来看看 Client 怎么实现:
108
109 package com.pattern.state.advance2;
110
111 /**
112  * 模拟电梯的动作
113  * @author http://www.cnblogs.com/initial-road/
114  *
115  */
116 public class Client {
117
118     public static void main(String[] args) {
119         Context context = new Context();
120         context.setLiftState(Context.closeingState);
121         context.open();
122         context.close();
123         context.run();
124         context.stop();
125     }
126
127 }

  Client 调用类太简单了,只要定义个电梯的初始状态,然后调用相关的方法,就完成了,完全不用考虑状态的变更。

  我们再来回顾一下我们刚刚批判上一段的代码,首先我们说人家代码太长,这个问题我们解决了,通过各个子类来实现,每个子类的代码都很短,而且也取消了的 switch…case 条件的判断;其次,说人家不符合开闭原则,那如果在我们这个例子中要增加两个状态怎么加?增加两个子类,一个是通电状态,一个是断电状态,同时修改其他实现类的相应方法,因为状态要过渡呀,那当然要修改原有的类,只是在原有 类中的方法上增加,而不去做修改;再其次,我们说人家不符合迪米特法则,我们现在呢是各个状态是单独的一个类,只有与这个状态的有关的因素修改了这个类才修改,符合迪米特法则,非常完美!

  上面例子中多次提到状态,那我们这节讲的就是状态模式,什么是状态模式呢? 当一个对象内在状态改变时允许其改变行为,这个对象看起来像是改变了其类。说实话,这个定义的后半句我也没看懂,看过GOF 才明白是怎么回事: Allow an object to alter its behavior when its internal statechanges. The object will appear to change its class. [GoF, p305],也就是说状态模式封装的非常好,状态的变更引起了行为的变更,从外部看起来就好像这个对象对应的类发生了改变一样。状态模式的通用实现类如下:

24种设计模式--状态模式【State Pattern】

  状态模式中有什么优点呢?首先是避免了过多的 swith…case 或者 if..else 语句的使用,避免了程序的复杂性;其次是很好的使用体现了开闭原则和单一职责原则,每个状态都是一个子类,你要增加状态就增加子类,你要修改状态,你只修改一个子类就可以了;最后一个好处就是封装性非常好,这也是状态模式的基本要求,状态变换放置到了类的内部来实现,外部的调用不用知道类内部如何实现状态和行为的变换。

  状态模式既然有优点,那当然有缺点了,只有一个缺点,子类会太多,也就是类膨胀,你想一个事物有七八、十来个状态也不稀奇,如果完全使用状态模式就会有太多的子类,不好管理,这个需要大家在项目自己衡量。其实有很多方式解决这个状态问题,比如在数据库中建立一个状态表,然后根据状态执行相应的操作,这个也不复杂,看大家的习惯和嗜好了。

  状态模式使用于当某个对象在它的状态发生改变时,它的行为也随着发生比较大的变化,也就是说行为是受状态约束的情况下可以使用状态模式,而且状态模式使用时对象的状态最好不要超过五个,防止你写子类写疯掉。

Similar Posts:

  • 设计模式 - 状态模式(state pattern) 未使用状态模式 详解

    状态模式(state pattern) 未使用状态模式 详解 本文地址: http://blog.csdn.net/caroline_wendy 状态模式可以控制状态的转换, 未使用设计模式时, 程序会非常繁杂. 具体方法: 1. 状态转换类. /** * @time 2014年7月11日 */ package state; /** * @author C.L.Wang * */ public class GumballMachine { final static int SOLD_OUT =

  • 设计模式学习--状态模式(State Pattern)

    概念 状态模式(State Pattern):允许对象在其内部状态改变时改变它的行为和特性,对象看起来好像修改了它的类. 问题 在某些组件内部,可以通过不同的状态修改组件的行为特性,让它看起来似乎是修改了对象类型的结构和行为.当你在一个对象的方法中使用选择语句来确定不同的状态下有不同的行为和特性时,可以考虑应用状态模式. 一般情况下,可以在状态中定义与对象中一一对应的方法,以确定对象在不同的状态下各个方法的行为方式. 如果状态的影响有一定的规则,可以在状态 类中使用一个方法来完成 解决方案 首先

  • 设计系列之状态模式(State Pattern)

    设计系列之状态模式(State Pattern) 意图 允许一个对象在其内部状态改变时改变它的行为.对象看起来似乎修改了它的类. 场景 我们在制作一个网上书店的网站,用户在书店买了一定金额的书后可以升级为银会员.黄金会员,不同等级的会员购买书籍有不同的优惠.你可能会想到可以在User类的BuyBook方法中判断用户历史消费的金额来给用户不同的折扣,在GetUserLevel方法中根据用户历史消费的金额来输出用户的等级.带来的问题有三点: l 不用等级的用户给予的优惠比率是经常发生变化的,一旦变化

  • 设计模式——状态模式(State)

    设计模式(20):状态模式(State) 状态模式(State) 定义 当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类. 动机 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况.把状态的判断逻辑转移到表示不同状态的一系列类当中,可以把复杂的判断逻辑简化.当一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为时,就可以考虑使用状态模式了. 状态模式(State)结构图 State类,抽象状态类,定义一个接口以封装与Context的一个

  • 极速理解设计模式系列:22.状态模式(State Pattern)

    四个角色:抽象状态类(State).具体状态类(ConcreateState).情景类(Context).客户端(Client) 抽象状态类(State):提供一个与情景类有关的State行为. 具体状态类(ConcreateState):实现这个行为,实现一个状态. 情景类(Context):维护一个State的实例对象,并且提供一个客户操作置换状态的接口. 客户端(Client):直接调用情景类操作即可. 实现思路:直接调用情景类,然后在情景类自动操作或者手动操作置换状态,并且取得不同结果.

  • 24种设计模式--策略模式【Strategy Pattern】

    刘备要到江东娶老婆了,走之前诸葛亮给赵云(伴郎)三个锦囊妙计,说是按天机拆开解决棘手问题,嘿,还别说,真是解决了大问题,搞到最后是周瑜赔了夫人有折兵呀,那咱们先看看这个场景是什么样子的. 先说这个场景中的要素:三个妙计,一个锦囊,一个赵云,妙计是小亮同志给的,妙计是放置在锦囊里,俗称就是锦囊妙计嘛,那赵云就是一个干活的人,从锦囊中取出妙计,执行,然后获胜,用Java程序怎么表现呢? 我们先看类图: 三个妙计是同一类型的东东,那咱就写个接口: 1 package com.iadmob.strate

  • java设计模式--[行为模式]--状态模式[state pattern]

    一. 狀態模式 允許一個對象在其內部狀態改變時改變它的行為.這個對象看起來似乎修改了它的類.看起來,狀態模式好像是神通廣大--居然可以修改自身的類! 二. 狀態模式包括三個角色: 1. 環境: 環境是一個類,該類含有抽象狀態聲明的變量,可以引用任何具體狀態類的實例. 2. 抽象狀態: 抽象狀態是一個接口或抽象類,定義了與環境的一個特定狀態相關的若干方法. 3.具體狀態: 具體狀態是實現(擴展)旬狀態(抽象類)的類. 三. 狀態模式的UML類圖如下: 四. 下面以一個冬簡單的實例來說明狀態的切換:

  • 24种设计模式--装饰模式【Decorator Pattern】

    装饰模式在中国使用的那实在是多,中国的文化是中庸文化,说话或做事情都不能太直接,需要有技巧的,比如说话吧,你要批评一个人,你不能一上来就说你这个做的不对,那个做的不对,你要先肯定他的成绩,表扬一下优点,然后再指出瑕疵,指出错误的地方,最后再来个激励,你修改了这些缺点后有那些好处,比如你能带更多的小兵,当个小头目等等,否则你一上来就是一顿批评,你瞅瞅看,肯定是不服气,顶撞甚至是直接"此处不养爷,自有养爷处"开溜哇.这是说话,那做事情也有很多,在山寨产品流行之前,假货很是比较盛行的,我在

  • DP:***24种设计模式--转自刘伟

    转自于高人的文章:http://blog.csdn.net/lovelion/article/details/17517213 2012年-2013年,Sunny在CSDN技术博客中陆续发表了100多篇与设计模式学习相关的文章,涵盖了七个面向对象设计原则和24个设计模式(23个GoF设计模式 +  简单工厂模式),为了方便大家学习,现将所有文章的链接进行了整理,希望能给各位带来帮助! 祝大家圣诞节快乐! 花絮:本文的工作量大大超过之前的估计,几乎整个平安夜都花在它身上了, 基础知识 设计模式概述

  • 设计模式 Design Parttern ——状态模式State

    设计模式 Design Parttern --状态模式State http://blog.csdn.net/leeidea //1:头文件 #ifndef _STATE_H_VANEY_ #define _STATE_H_VANEY_ #include <iostream> using namespace std; /****************************************************************** 名称 :State.h 版本 :1.00 描

Tags: