状态模式

一、状态模式简介
        首先了解一下基本的概念！
1.什么是状态模式
       状态模式（State Pattern），当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。
2.状态模式是用来解决什么问题的？是用来干什么的？
       状态模式主要解决的是当控制一个对象状态装换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简单化。
       当一个对象行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。
3.状态模式的结构
Context类：维护一个ConcreteState子类的一个实例，这个实例定义当前的状态。
State类：抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为。
ConcreteStateA,ConcreteStateB,ConcreteStateC类：具体状态类，每一个子类实现一个与Context的一个状态相关的行为。
       看完这些概念之后，其实我对状态模式还是很模糊，不知道你们呢？不过通过下面的例子，我们就能很好的理解状态模式了~！
 
 
二、Demo
       我们通过实现投篮机的代码来理解状态模式！
       首先我们来看下，投篮机的状态图：
       从上面我们可以知道，投篮机一共有三个状态（已投币，计分中，未投币），有三个动作（退币，投币，按下开始按钮），其中每个状态下都有可能发生这三个动作，就比如在未投币的状态中，你都可以选择投币，退币和按下开始按钮的动作！好了，分析完之后，我们可以用三个常两来表示三种状态，用三个方法来实现这三个动作！具体看代码：
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. /** 
  4.  * 投篮机1 
  5.  *  
  6.  * @author liangdianshui 
  7.  * 
  8.  */  
  9. public class ShootingMachine {  
  10.   
  11.     // 投篮机有三个状态（已投币，未投币，计分中），分别用三个常量来表示  
  12.     private final static int HAS_COIN = 0;  
  13.     private final static int NO_COIN = 1;  
  14.     private final static int SCORING = 2;  
  15.   
  16.     private int mCurrentStatus = NO_COIN;  
  17.   
  18.     /** 
  19.      * 初始化的时候，设置投篮机的状态为未投币的状态 
  20.      */  
  21.     public ShootingMachine() {  
  22.         mCurrentStatus = NO_COIN;  
  23.     }  
  24.   
  25.     /** 
  26.      * 投币的动作（方法） 玩家在上面的三种状态中都有可能投币 
  27.      */  
  28.     public void insertCoin() {  
  29.         switch (mCurrentStatus) {  
  30.         case HAS_COIN:  
  31.             System.out.println("已有硬币，不需要重复投币");  
  32.             break;  
  33.         case NO_COIN:  
  34.             mCurrentStatus = HAS_COIN;  
  35.             System.out.println("投币成功");  
  36.             break;  
  37.         case SCORING:  
  38.             System.out.println("游戏正在开始，请稍后投币");  
  39.             break;  
  40.         }  
  41.     }  
  42.   
  43.     /** 
  44.      * 退币的动作（方法） 玩家在上面的三种状态中都有可能退币 
  45.      */  
  46.     public void backtCoin() {  
  47.         switch (mCurrentStatus) {  
  48.         case HAS_COIN:  
  49.             mCurrentStatus = NO_COIN;  
  50.             System.out.println("退币成功");  
  51.             break;  
  52.         case NO_COIN:  
  53.             System.out.println("未投入硬币");  
  54.             break;  
  55.         case SCORING:  
  56.             System.out.println("游戏正在进行，不能退币");  
  57.             break;  
  58.         }  
  59.     }  
  60.   
  61.     /** 
  62.      * 按下开始按钮的动作（方法） 玩家在上面的三种状态中都有可能按下开始的按钮 
  63.      */  
  64.     public void startScoring() {  
  65.         switch (mCurrentStatus) {  
  66.         case HAS_COIN:  
  67.             mCurrentStatus = SCORING;  
  68.             System.out.println("游戏开始进行");  
  69.             scoring();  
  70.             break;  
  71.         case NO_COIN:  
  72.             System.out.println("请投币");  
  73.             break;  
  74.         case SCORING:  
  75.             System.out.println("游戏正在进行");  
  76.             break;  
  77.         }  
  78.     }  
  79.   
  80.     /** 
  81.      * 投篮机计分中 
  82.      */  
  83.     public void scoring() {  
  84.         try {  
  85.             Thread.sleep(1000); // 模拟时间  
  86.             System.out.println("时间到，游戏结束");  
  87.         } catch (InterruptedException e) {  
  88.             e.printStackTrace();  
  89.         }  
  90.         mCurrentStatus = NO_COIN;  
  91.     }  
  92.   
  93. }  
测试类代码：
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. public class Test {  
  4.     public static void main(String[] args) {  
  5.         ShootingMachine machine = new ShootingMachine();  
  6.         System.out.println("----------投币退币---------");  
  7.         machine.insertCoin();  
  8.         machine.backtCoin();  
  9.   
  10.         System.out.println("----------投币计分---------");  
  11.   
  12.         machine.insertCoin();  
  13.         machine.startScoring();  
  14.   
  15.         System.out.println("----------压力测试---------");  
  16.         machine.insertCoin();  
  17.         machine.insertCoin();  
  18.         machine.backtCoin();  
  19.         machine.backtCoin();  
  20.         machine.backtCoin();  
  21.         machine.startScoring();  
  22.         machine.startScoring();  
  23.         machine.backtCoin();  
  24.     }  
  25. }  
实现的效果：
          好了，感觉写得不错！可是如果需要增加一个奖励，比如投篮投进多少分，给他们出个奖品卷，那么投篮机就多了一个出奖品卷的状态了，按照上面的代码，我们需要在每个动作方法中的判断语句（switch）中增加出奖品卷的状态，如果加一个状态还好，如果很多个，修改起来就很部方便了，而且很容易出错！那么我们可以这样写，写一个状态类，封装好每个状态的方法，然后再让每个状态去实现这些方法，这样修改就比较方便了！
       看下增加出奖品卷的状态的状态图：
状态的接口：
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. public interface State {  
  4.   
  5.     // 投币  
  6.     public void insertCoin();  
  7.   
  8.     // 退币  
  9.     public void backtCoin();  
  10.   
  11.     // 按下开始按钮  
  12.     public void startScoring();  
  13.   
  14.     // 投篮机计分中  
  15.     public void scoring();  
  16.   
  17.     // 出奖品卷  
  18.     public void putPrizeRoll();  
  19. }  
每个状态的实现类：
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. /** 
  4.  * 有投币的状态 
  5.  *  
  6.  * @author liangdianshui 
  7.  * 
  8.  */  
  9. public class HasCoinState implements State {  
  10.   
  11.     private ShootingMachine mShootingMachine;  
  12.   
  13.     public HasCoinState(ShootingMachine shootingMachine) {  
  14.         this.mShootingMachine = shootingMachine;  
  15.     }  
  16.   
  17.     @Override  
  18.     public void insertCoin() {  
  19.         // TODO Auto-generated method stub  
  20.         System.out.println("已有硬币，不需要重复投币");  
  21.     }  
  22.   
  23.     @Override  
  24.     public void backtCoin() {  
  25.         // TODO Auto-generated method stub  
  26.         System.out.println("退币成功");  
  27.         mShootingMachine.setState(mShootingMachine.getNoCoinState());  
  28.     }  
  29.   
  30.     @Override  
  31.     public void startScoring() {  
  32.         // TODO Auto-generated method stub  
  33.         System.out.println("游戏开始进行");  
  34.         mShootingMachine.setState(mShootingMachine.getScoringState());  
  35.         mShootingMachine.scoring();  
  36.     }  
  37.   
  38.     @Override  
  39.     public void scoring() {  
  40.         // TODO Auto-generated method stub  
  41.   
  42.     }  
  43.   
  44.     @Override  
  45.     public void putPrizeRoll() {  
  46.         // TODO Auto-generated method stub  
  47.   
  48.     }  
  49.   
  50. }  
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. /** 
  4.  * 未投币的状态 
  5.  *  
  6.  * @author liangdianshui 
  7.  * 
  8.  */  
  9. public class NoCoinState implements State {  
  10.   
  11.     private ShootingMachine mShootingMachine;  
  12.   
  13.     public NoCoinState(ShootingMachine shootingMachine) {  
  14.         this.mShootingMachine = shootingMachine;  
  15.     }  
  16.   
  17.     @Override  
  18.     public void insertCoin() {  
  19.         // TODO Auto-generated method stub  
  20.         System.out.println("投币成功");  
  21.         mShootingMachine.setState(mShootingMachine.getHasCoinState());  
  22.     }  
  23.   
  24.     @Override  
  25.     public void backtCoin() {  
  26.         // TODO Auto-generated method stub  
  27.         System.out.println("未投入硬币");  
  28.     }  
  29.   
  30.     @Override  
  31.     public void startScoring() {  
  32.         // TODO Auto-generated method stub  
  33.         System.out.println("请投币");  
  34.     }  
  35.   
  36.     @Override  
  37.     public void scoring() {  
  38.         // TODO Auto-generated method stub  
  39.   
  40.     }  
  41.   
  42.     @Override  
  43.     public void putPrizeRoll() {  
  44.         // TODO Auto-generated method stub  
  45.           
  46.     }  
  47.   
  48. }  
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. /** 
  4.  * 出奖品卷的状态 
  5.  *  
  6.  * @author liangdianshui 
  7.  * 
  8.  */  
  9. public class PutPrizeRollState implements State {  
  10.   
  11.     private ShootingMachine mShootingMachine;  
  12.   
  13.     public PutPrizeRollState(ShootingMachine shootingMachine) {  
  14.         this.mShootingMachine = shootingMachine;  
  15.     }  
  16.   
  17.     @Override  
  18.     public void insertCoin() {  
  19.         // TODO Auto-generated method stub  
  20.         System.out.println("正在出奖品卷，请稍后投币");  
  21.     }  
  22.   
  23.     @Override  
  24.     public void backtCoin() {  
  25.         // TODO Auto-generated method stub  
  26.         System.out.println("正在出奖品卷，不能退币");  
  27.     }  
  28.   
  29.     @Override  
  30.     public void startScoring() {  
  31.         // TODO Auto-generated method stub  
  32.         System.out.println("正在出奖品卷，不能开始游戏");  
  33.     }  
  34.   
  35.     @Override  
  36.     public void scoring() {  
  37.         // TODO Auto-generated method stub  
  38.   
  39.     }  
  40.   
  41.     @Override  
  42.     public void putPrizeRoll() {  
  43.         // TODO Auto-generated method stub  
  44.         try {  
  45.             Thread.sleep(1000); // 模拟出奖品卷  
  46.             System.out.println("出奖品卷完成");  
  47.             mShootingMachine.setState(mShootingMachine.getNoCoinState());  
  48.         } catch (InterruptedException e) {  
  49.             // TODO Auto-generated catch block  
  50.             e.printStackTrace();  
  51.         }  
  52.     }  
  53.   
  54. }  
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. import java.util.Random;  
  4.   
  5. /** 
  6.  * 计分中的状态 
  7.  *  
  8.  * @author liangdianshui 
  9.  * 
  10.  */  
  11. public class ScoringState implements State {  
  12.   
  13.     private ShootingMachine mShootingMachine;  
  14.     private Random random = new Random();  
  15.   
  16.     public ScoringState(ShootingMachine shootingMachine) {  
  17.         this.mShootingMachine = shootingMachine;  
  18.     }  
  19.   
  20.     @Override  
  21.     public void insertCoin() {  
  22.         // TODO Auto-generated method stub  
  23.         System.out.println("游戏正在开始，请稍后投币");  
  24.     }  
  25.   
  26.     @Override  
  27.     public void backtCoin() {  
  28.         // TODO Auto-generated method stub  
  29.         System.out.println("游戏正在进行，不能退币");  
  30.     }  
  31.   
  32.     @Override  
  33.     public void startScoring() {  
  34.         // TODO Auto-generated method stub  
  35.         System.out.println("游戏正在进行");  
  36.         scoring();  
  37.     }  
  38.   
  39.     @Override  
  40.     public void scoring() {  
  41.         // TODO Auto-generated method stub  
  42.         int randNum = random.nextInt(80) + 15; // 随机生成15到94的一个随机数，代表游戏的分数  
  43.         try {  
  44.             Thread.sleep(1000); // 模拟时间  
  45.             if (randNum > 50) {  
  46.                 System.out.println("时间到，您的分数是：" + randNum + ",恭喜你获取到奖品卷");  
  47.                 mShootingMachine.setState(mShootingMachine.getPutPrizeRollState());  
  48.                 mShootingMachine.putPrizeRollState();  
  49.             } else {  
  50.                 System.out.println("时间到，您的分数是：" + randNum + ",游戏结束");  
  51.             }  
  52.         } catch (InterruptedException e) {  
  53.             e.printStackTrace();  
  54.         }  
  55.     }  
  56.   
  57.     @Override  
  58.     public void putPrizeRoll() {  
  59.         // TODO Auto-generated method stub  
  60.   
  61.     }  
  62.   
  63. }  
然后写个投篮机的实现类：
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. /** 
  4.  * 投篮机2 
  5.  *  
  6.  * @author liangdianshui 
  7.  * 
  8.  */  
  9. public class ShootingMachine {  
  10.   
  11.     private State hasCoinState;  
  12.     private State noCoinState;  
  13.     private State putPrizeRollState;  
  14.     private State scoringState;  
  15.   
  16.     private State mCurrentStatus = noCoinState;  
  17.   
  18.     public ShootingMachine() {  
  19.         hasCoinState = new HasCoinState(this);  
  20.         noCoinState = new NoCoinState(this);  
  21.         putPrizeRollState = new PutPrizeRollState(this);  
  22.         scoringState = new ScoringState(this);  
  23.         mCurrentStatus = noCoinState;  
  24.     }  
  25.   
  26.     /** 
  27.      * 设置投篮机的状态 
  28.      */  
  29.     public void setState(State state) {  
  30.         this.mCurrentStatus = state;  
  31.     }  
  32.   
  33.     // 投币  
  34.     public void insertCoin() {  
  35.         mCurrentStatus.insertCoin();  
  36.     }  
  37.   
  38.     // 退币  
  39.     public void backtCoin() {  
  40.         mCurrentStatus.backtCoin();  
  41.     }  
  42.   
  43.     // 按下开始游戏的按钮  
  44.     public void startScoring() {  
  45.         mCurrentStatus.startScoring();  
  46.     }  
  47.   
  48.     // 投篮机计分中  
  49.     public void scoring() {  
  50.         mCurrentStatus.scoring();  
  51.     }  
  52.   
  53.     // 出奖品卷  
  54.     public void putPrizeRollState() {  
  55.         mCurrentStatus.putPrizeRoll();  
  56.     }  
  57.   
  58.     public State getHasCoinState() {  
  59.         return hasCoinState;  
  60.     }  
  61.   
  62.     public void setHasCoinState(State hasCoinState) {  
  63.         this.hasCoinState = hasCoinState;  
  64.     }  
  65.   
  66.     public State getNoCoinState() {  
  67.         return noCoinState;  
  68.     }  
  69.   
  70.     public void setNoCoinState(State noCoinState) {  
  71.         this.noCoinState = noCoinState;  
  72.     }  
  73.   
  74.     public State getPutPrizeRollState() {  
  75.         return putPrizeRollState;  
  76.     }  
  77.   
  78.     public void setPutPrizeRollState(State putPrizeRollState) {  
  79.         this.putPrizeRollState = putPrizeRollState;  
  80.     }  
  81.   
  82.     public State getScoringState() {  
  83.         return scoringState;  
  84.     }  
  85.   
  86.     public void setScoringState(State scoringState) {  
  87.         this.scoringState = scoringState;  
  88.     }  
  89.   
  90. }  
测试类：
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.liangdianshui;  
  2.   
  3. public class Test {  
  4.     public static void main(String[] args) {  
  5.         ShootingMachine machine = new ShootingMachine();  
  6.         System.out.println("----------投币退币---------");  
  7.         machine.insertCoin();  
  8.         machine.backtCoin();  
  9.   
  10.         System.out.println("----------投币，开始投篮1---------");  
  11.         machine.insertCoin();  
  12.         machine.startScoring();  
  13.   
  14.         System.out.println("----------投币，开始投篮2---------");  
  15.         machine.insertCoin();  
  16.         machine.startScoring();  
  17.   
  18.         System.out.println("----------投币，开始投篮3---------");  
  19.         machine.insertCoin();  
  20.         machine.startScoring();  
  21.   
  22.         System.out.println("----------压力测试---------");  
  23.         machine.insertCoin();  
  24.         machine.insertCoin();  
  25.         machine.backtCoin();  
  26.         machine.backtCoin();  
  27.         machine.backtCoin();  
  28.         machine.startScoring();  
  29.         machine.startScoring();  
  30.         machine.backtCoin();  
  31.     }  
  32. }  
最后来看下运行的结果：
posted on 2014-02-24 12:58  duanxz  阅读(892)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 duanxz
Powered by .NET 8.0 on Kubernetes