码迷，mamicode.com
首页 > 编程语言 > 详细

《Java设计模式》之状态模式

时间：2015-08-20 09:11:26      阅读：198      评论：0      收藏：0      [点我收藏+]

标签：

　状态模式，又称状态对象模式（Pattern of Objects for States），状态模式是对象的行为模式。

　　状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样。


定义与结构

　　GOF《设计模式》中给状态模式下的定义为：允许一个对象在其内部状态改变时改变它的行为。这个对象看起来似乎修改了它的类。看起来，状态模式好像是神通广大——居然能够“修改自身的类”！

　　能够让程序根据不同的外部情况来做出不同的响应，最直接的方法就是在程序中将这些可能发生的外部情况全部考虑到，使用if else 语句来进行代码响应选择。但是这种方法对于复杂一点的状态判断，就会显得杂乱无章，容易产生错误；而且增加一个新的状态将会带来大量的修改。这个时候“能够修改自身”的状态模式的引入也许是个不错的主意。

状态模式的结构

　　用一句话来表述，状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式的示意性类图如下所示：

技术分享

　类图如下，结构非常简单也与策略模式非常相似。

技术分享

 技术分享

　　状态模式所涉及到的角色有：

　　●　　环境(Context)角色，也成上下文：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态。

　　●　　抽象状态(State)角色：定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为。

　　●　　具体状态(ConcreteState)角色：每一个具体状态类都实现了环境（Context）的一个状态所对应的行为。

　　源代码

　　环境角色类

[java] view plaincopyprint?
  1. package com.bankht.State;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:34:57 
  6.  *  
  7.  * @类说明 ：环境角色类 
  8.  */  
  9. public class Context {  
  10.     // 持有一个State类型的对象实例  
  11.     private State state;  
  12.   
  13.     public void setState(State state) {  
  14.         this.state = state;  
  15.     }  
  16.   
  17.     /** 
  18.      * 用户感兴趣的接口方法 
  19.      */  
  20.     public void request(String sampleParameter) {  
  21.         // 转调state来处理  
  22.         state.handle(sampleParameter);  
  23.     }  
  24. }  


 

　　抽象状态类

[java] view plaincopyprint?
  1. package com.bankht.State;  
  2. /**  
  3.  * @author: 特种兵—AK47  
  4.  * @创建时间：2012-7-3 上午09:35:29  
  5.  * 
  6.  * @类说明 ：抽象状态类 
  7.  
  8.  */  
  9. public interface State {  
  10.     /** 
  11.      * 状态对应的处理 
  12.      */  
  13.     public void handle(String sampleParameter);  
  14. }  


 

　　具体状态类

[java] view plaincopyprint?
  1. package com.bankht.State;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:35:52 
  6.  *  
  7.  * @类说明 ：具体状态类 
  8.  */  
  9. public class ConcreteStateA implements State {  
  10.   
  11.     @Override  
  12.     public void handle(String sampleParameter) {  
  13.   
  14.         System.out.println("ConcreteStateA handle ：" + sampleParameter);  
  15.     }  
  16.   
  17. }  


 

[java] view plaincopyprint?
  1. package com.bankht.State;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:36:15 
  6.  *  
  7.  * @类说明 ： 
  8.  */  
  9. public class ConcreteStateB implements State {  
  10.   
  11.     @Override  
  12.     public void handle(String sampleParameter) {  
  13.   
  14.         System.out.println("ConcreteStateB handle ：" + sampleParameter);  
  15.     }  
  16.   
  17. }  


 

　　客户端类

[java] view plaincopyprint?
  1. package com.bankht.State;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:36:33 
  6.  *  
  7.  * @类说明 ： 
  8.  */  
  9. public class Client {  
  10.   
  11.     public static void main(String[] args) {  
  12.         // 创建状态  
  13.         State state = new ConcreteStateB();  
  14.         // 创建环境  
  15.         Context context = new Context();  
  16.         // 将状态设置到环境中  
  17.         context.setState(state);  
  18.         // 请求  
  19.         context.request("test");  
  20.     }  
  21. }  


 

　　从上面可以看出，环境类Context的行为request()是委派给某一个具体状态类的。通过使用多态性原则，可以动态改变环境类Context的属性State的内容，使其从指向一个具体状态类变换到指向另一个具体状态类，从而使环境类的行为request()由不同的具体状态类来执行。

使用场景

　　考虑一个在线投票系统的应用，要实现控制同一个用户只能投一票，如果一个用户反复投票，而且投票次数超过5次，则判定为恶意刷票，要取消该用户投票的资格，当然同时也要取消他所投的票；如果一个用户的投票次数超过8次，将进入黑名单，禁止再登录和使用系统。

　　要使用状态模式实现，首先需要把投票过程的各种状态定义出来，根据以上描述大致分为四种状态：正常投票、反复投票、恶意刷票、进入黑名单。然后创建一个投票管理对象（相当于Context）。

　　系统的结构图如下所示：

技术分享

　　源代码

　　抽象状态类

[java] view plaincopyprint?
  1. package com.bankht.State.Vote;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:39:41 
  6.  *  
  7.  * @类说明 ： 
  8.  */  
  9. public interface VoteState {  
  10.     /** 
  11.      * 处理状态对应的行为 
  12.      *  
  13.      * @param user 
  14.      *            投票人 
  15.      * @param voteItem 
  16.      *            投票项 
  17.      * @param voteManager 
  18.      *            投票上下文，用来在实现状态对应的功能处理的时候， 可以回调上下文的数据 
  19.      */  
  20.     public void vote(String user, String voteItem, VoteManager voteManager);  
  21. }  


 

　　具体状态类——正常投票

[java] view plaincopyprint?
  1. package com.bankht.State.Vote;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:40:00 
  6.  *  
  7.  * @类说明 ：具体状态类——正常投票 
  8.  */  
  9. public class NormalVoteState implements VoteState {  
  10.   
  11.     @Override  
  12.     public void vote(String user, String voteItem, VoteManager voteManager) {  
  13.         // 正常投票，记录到投票记录中  
  14.         voteManager.getMapVote().put(user, voteItem);  
  15.         System.out.println("恭喜投票成功");  
  16.     }  
  17.   
  18. }  


 

　　具体状态类——重复投票

[java] view plaincopyprint?
  1. package com.bankht.State.Vote;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:40:23 
  6.  *  
  7.  * @类说明 ：具体状态类——重复投票 
  8.  */  
  9. public class RepeatVoteState implements VoteState {  
  10.   
  11.     @Override  
  12.     public void vote(String user, String voteItem, VoteManager voteManager) {  
  13.         // 重复投票，暂时不做处理  
  14.         System.out.println("请不要重复投票");  
  15.     }  
  16.   
  17. }  


 

　　具体状态类——恶意刷票

[java] view plaincopyprint?
  1. package com.bankht.State.Vote;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:40:50 
  6.  *  
  7.  * @类说明 ：具体状态类——恶意刷票 
  8.  */  
  9. public class SpiteVoteState implements VoteState {  
  10.   
  11.     @Override  
  12.     public void vote(String user, String voteItem, VoteManager voteManager) {  
  13.         // 恶意投票，取消用户的投票资格，并取消投票记录  
  14.         String str = voteManager.getMapVote().get(user);  
  15.         if (str != null) {  
  16.             voteManager.getMapVote().remove(user);  
  17.         }  
  18.         System.out.println("你有恶意刷屏行为，取消投票资格");  
  19.     }  
  20.   
  21. }  


 

　　具体状态类——黑名单

[java] view plaincopyprint?
  1. package com.bankht.State.Vote;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:41:15 
  6.  *  
  7.  * @类说明 ：具体状态类——黑名单 
  8.  */  
  9. public class BlackVoteState implements VoteState {  
  10.   
  11.     @Override  
  12.     public void vote(String user, String voteItem, VoteManager voteManager) {  
  13.         // 记录黑名单中，禁止登录系统  
  14.         System.out.println("进入黑名单，将禁止登录和使用本系统");  
  15.     }  
  16.   
  17. }  

　　环境类

[java] view plaincopyprint?
  1. package com.bankht.State.Vote;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5.   
  6. /** 
  7.  * @author: 特种兵—AK47 
  8.  * @创建时间：2012-7-3 上午09:41:35 
  9.  *  
  10.  * @类说明 ：环境类 
  11.  */  
  12. public class VoteManager {  
  13.     // 持有状体处理对象  
  14.     private VoteState state = null;  
  15.     // 记录用户投票的结果，Map<String,String>对应Map<用户名称，投票的选项>  
  16.     private Map<String, String> mapVote = new HashMap<String, String>();  
  17.     // 记录用户投票次数，Map<String,Integer>对应Map<用户名称，投票的次数>  
  18.     private Map<String, Integer> mapVoteCount = new HashMap<String, Integer>();  
  19.   
  20.     /** 
  21.      * 获取用户投票结果的Map 
  22.      */  
  23.     public Map<String, String> getMapVote() {  
  24.         return mapVote;  
  25.     }  
  26.   
  27.     /** 
  28.      * 投票 
  29.      *  
  30.      * @param user 
  31.      *            投票人 
  32.      * @param voteItem 
  33.      *            投票的选项 
  34.      */  
  35.     public void vote(String user, String voteItem) {  
  36.         // 1.为该用户增加投票次数  
  37.         // 从记录中取出该用户已有的投票次数  
  38.         Integer oldVoteCount = mapVoteCount.get(user);  
  39.         if (oldVoteCount == null) {  
  40.             oldVoteCount = 0;  
  41.         }  
  42.         oldVoteCount += 1;  
  43.         mapVoteCount.put(user, oldVoteCount);  
  44.         // 2.判断该用户的投票类型，就相当于判断对应的状态  
  45.         // 到底是正常投票、重复投票、恶意投票还是上黑名单的状态  
  46.         //下面使用本人自创常用的“假设修正法” 完成switch的结构  
  47.         if(oldVoteCount == 1 ) {  
  48.             state = new NormalVoteState();  
  49.         }  
  50.         if(oldVoteCount > 1 ) {  
  51.             state = new RepeatVoteState();  
  52.         }  
  53.         if(oldVoteCount > 5 ) {  
  54.             state = new SpiteVoteState();  
  55.         }  
  56.         if(oldVoteCount > 8 ) {  
  57.             state = new BlackVoteState();  
  58.         }  
  59.           
  60. //      if (oldVoteCount == 1) {  
  61. //          state = new NormalVoteState();  
  62. //      } else if (oldVoteCount > 1 && oldVoteCount < 5) {  
  63. //          state = new RepeatVoteState();  
  64. //      } else if (oldVoteCount >= 5 && oldVoteCount < 8) {  
  65. //          state = new SpiteVoteState();  
  66. //      } else if (oldVoteCount > 8) {  
  67. //          state = new BlackVoteState();  
  68. //      }  
  69.           
  70.         // 然后转调状态对象来进行相应的操作  
  71.         state.vote(user, voteItem, this);  
  72.     }  
  73. }  


 

　　客户端类

[java] view plaincopyprint?
  1. package com.bankht.State.Vote;  
  2.   
  3. /** 
  4.  * @author: 特种兵—AK47 
  5.  * @创建时间：2012-7-3 上午09:42:06 
  6.  *  
  7.  * @类说明 ：客户端类 
  8.  */  
  9. public class Client {  
  10.   
  11.     public static void main(String[] args) {  
  12.   
  13.         VoteManager vm = new VoteManager();  
  14.         for (int i = 0; i < 11; i++) {  
  15.             vm.vote("u1", "A");  
  16.         }  
  17.     }  
  18.   
  19. }  


 

　　运行结果如下：

[html] view plaincopyprint?
  1. 恭喜投票成功  
  2. 请不要重复投票  
  3. 请不要重复投票  
  4. 请不要重复投票  
  5. 请不要重复投票  
  6. 你有恶意刷屏行为，取消投票资格  
  7. 你有恶意刷屏行为，取消投票资格  
  8. 你有恶意刷屏行为，取消投票资格  
  9. 进入黑名单，将禁止登录和使用本系统  
  10. 进入黑名单，将禁止登录和使用本系统  
  11. 进入黑名单，将禁止登录和使用本系统  


 

　　从上面的示例可以看出，状态的转换基本上都是内部行为，主要在状态模式内部来维护。比如对于投票的人员，任何时候他的操作都是投票，但是投票管理对象的处理却不一定一样，会根据投票的次数来判断状态，然后根据状态去选择不同的处理。

认识状态模式

　　●　　状态和行为

　　所谓对象的状态，通常指的就是对象实例的属性的值；而行为指的就是对象的功能，再具体点说，行为大多可以对应到方法上。

　　状态模式的功能就是分离状态的行为，通过维护状态的变化，来调用不同状态对应的不同功能。也就是说，状态和行为是相关联的，它们的关系可以描述为：状态决定行为。

　　由于状态是在运行期被改变的，因此行为也会在运行期根据状态的改变而改变。

　　●　　行为的平行性

　　注意平行线而不是平等性。所谓平行性指的是各个状态的行为所处的层次是一样的，相互独立的、没有关联的，是根据不同的状态来决定到底走平行线的哪一条。行为是不同的，当然对应的实现也是不同的，相互之间是不可替换的。

技术分享

　　而平等性强调的是可替换性，大家是同一行为的不同描述或实现，因此在同一个行为发生的时候，可以根据条件挑选任意一个实现来进行相应的处理。

技术分享

　　大家可能会发现状态模式的结构和策略模式的结构完全一样，但是，它们的目的、实现、本质却是完全不一样的。还有行为之间的特性也是状态模式和策略模式一个很重要的区别，状态模式的行为是平行性的，不可相互替换的；而策略模式的行为是平等性的，是可以相互替换的。

　　● 　　环境和状态处理对象

　　在状态模式中，环境(Context)是持有状态的对象，但是环境(Context)自身并不处理跟状态相关的行为，而是把处理状态的功能委托给了状态对应的状态处理类来处理。

　　在具体的状态处理类中经常需要获取环境(Context)自身的数据，甚至在必要的时候会回调环境(Context)的方法，因此，通常将环境(Context)自身当作一个参数传递给具体的状态处理类。

　　客户端一般只和环境(Context)交互。客户端可以用状态对象来配置一个环境(Context)，一旦配置完毕，就不再需要和状态对象打交道了。客户端通常不负责运行期间状态的维护，也不负责决定后续到底使用哪一个具体的状态处理对象。


状态VS策略

　　仔细对比状态模式和策略模式，难免会产生疑问：这两个明明是一个东西嘛！下面我们就来分析下两者区别。

　　首先我要声明，在实际应用中只要能够使得你的代码灵活漂亮起来，何必计较这些方方面面的差别呢？

　　Brandon Goldfedder在《模式的乐趣》里是怎么说的：“strategy模式在结构上与state模式非常相似，但是在概念上，他们的目的差异非常大。区分这两个模式的关键是看行为是由状态驱动还是由一组算法驱动，这条规则似乎有点随意，但是在判断时还是需要考虑它。通常，State模式的“状态”是在对象内部的，Strategy模式的“策略”可以在对象外部，不过这也不是一条严格、可靠的规则。”

　　我很同意Brandon Goldfedder的观点。这两个模式的划分，就在于使用的目的是不同的——策略模式用来处理算法变化，而状态模式则是处理状态变化（好玄乎阿）。

　　策略模式中，算法是否变化完全是由客户程序开决定的，而且往往一次只能选择一种算法，不存在算法中途发生变化的情况。从《深入浅出策略模式》中的例子可以很好的看出。

　　而状态模式如定义中所言，在它的生命周期中存在着状态的转变和行为得更改，而且状态变化是一个线形的整体；对于客户程序来言，这种状态变化往往是透明的。



本文借鉴博客：

http://www.cnblogs.com/java-my-life/archive/2012/06/08/2538146.html

http://dev.yesky.com/438/2164938.shtml

http://blog.csdn.net/column/details/loveyun.html?&page=1http://www.cnblogs.com/BenWong/archive/2012/12/12/2813982.html


 

版权声明：欢迎转载，希望在你转载的同时，添加原文地址，谢谢配合

《Java设计模式》之状态模式

标签：

原文地址：http://blog.csdn.net/u011225629/article/details/47802393
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！