设计模式之状态模式——自动售货机

最新推荐文章于 2024-09-23 17:11:27 发布
最新推荐文章于 2024-09-23 17:11:27 发布
阅读量1k 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 状态模式

转载自：http://blog.csdn.net/lmj623565791/article/details/26350617


先看定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。定义又开始模糊了，理一下，当对象的内部状态改变时，它的行为跟随状态的改变而改变了，看起来好像重新初始化了一个类似的。

下面使用个例子来说明状态模式的用法，现在有个自动售货机的代码需要我们来写，状态图如下：


分析一个这个状态图：

a、包含4个状态（我们使用4个int型常量来表示）

b、包含3个暴露在外的方法（投币、退币、转动手柄）

c、我们需要处理每个状态下，用户都可以触发这三个动作。

下面我们根据分析的结果，写出代码：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status;  
  2.   
  3. /** 
  4.  * 自动售货机 
  5.  *  
  6.  * @author zhy 
  7.  *  
  8.  */  
  9. public class VendingMachine  
  10. {  
  11.   
  12.     /** 
  13.      * 已投币 
  14.      */  
  15.     private final static int HAS_MONEY = 0;  
  16.     /** 
  17.      * 未投币 
  18.      */  
  19.     private final static int NO_MONEY = 1;  
  20.     /** 
  21.      * 售出商品 
  22.      */  
  23.     private final static int SOLD = 2;  
  24.     /** 
  25.      * 商品售罄 
  26.      */  
  27.     private final static int SOLD_OUT = 3;  
  28.   
  29.     private int currentStatus = NO_MONEY;  
  30.     /** 
  31.      * 商品数量 
  32.      */  
  33.     private int count = 0;  
  34.   
  35.     public VendingMachine(int count)  
  36.     {  
  37.         this.count = count;  
  38.         if (count > 0)  
  39.         {  
  40.             currentStatus = NO_MONEY;  
  41.         }  
  42.     }  
  43.   
  44.     /** 
  45.      * 投入硬币，任何状态用户都可能投币 
  46.      */  
  47.     public void insertMoney()  
  48.     {  
  49.         switch (currentStatus)  
  50.         {  
  51.         case NO_MONEY:  
  52.             currentStatus = HAS_MONEY;  
  53.             System.out.println("成功投入硬币");  
  54.             break;  
  55.         case HAS_MONEY:  
  56.             System.out.println("已经有硬币，无需投币");  
  57.             break;  
  58.         case SOLD:  
  59.             System.out.println("请稍等...");  
  60.             break;  
  61.         case SOLD_OUT:  
  62.             System.out.println("商品已经售罄，请勿投币");  
  63.             break;  
  64.   
  65.         }  
  66.     }  
  67.   
  68.     /** 
  69.      * 退币，任何状态用户都可能退币 
  70.      */  
  71.     public void backMoney()  
  72.     {  
  73.         switch (currentStatus)  
  74.         {  
  75.         case NO_MONEY:  
  76.             System.out.println("您未投入硬币");  
  77.             break;  
  78.         case HAS_MONEY:  
  79.             currentStatus = NO_MONEY;  
  80.             System.out.println("退币成功");  
  81.             break;  
  82.         case SOLD:  
  83.             System.out.println("您已经买了糖果...");  
  84.             break;  
  85.         case SOLD_OUT:  
  86.             System.out.println("您未投币...");  
  87.             break;  
  88.         }  
  89.     }  
  90.   
  91.     /** 
  92.      * 转动手柄购买,任何状态用户都可能转动手柄 
  93.      */  
  94.     public void turnCrank()  
  95.     {  
  96.         switch (currentStatus)  
  97.         {  
  98.         case NO_MONEY:  
  99.             System.out.println("请先投入硬币");  
  100.             break;  
  101.         case HAS_MONEY:  
  102.             System.out.println("正在出商品....");  
  103.             currentStatus = SOLD;  
  104.             dispense();  
  105.             break;  
  106.         case SOLD:  
  107.             System.out.println("连续转动也没用...");  
  108.             break;  
  109.         case SOLD_OUT:  
  110.             System.out.println("商品已经售罄");  
  111.             break;  
  112.   
  113.         }  
  114.     }  
  115.   
  116.     /** 
  117.      * 发放商品 
  118.      */  
  119.     private void dispense()  
  120.     {  
  121.   
  122.         switch (currentStatus)  
  123.         {  
  124.         case NO_MONEY:  
  125.         case HAS_MONEY:  
  126.         case SOLD_OUT:  
  127.             throw new IllegalStateException("非法的状态...");  
  128.         case SOLD:  
  129.             count--;  
  130.             System.out.println("发出商品...");  
  131.             if (count == 0)  
  132.             {  
  133.                 System.out.println("商品售罄");  
  134.                 currentStatus = SOLD_OUT;  
  135.             } else  
  136.             {  
  137.                 currentStatus = NO_MONEY;  
  138.             }  
  139.             break;  
  140.   
  141.         }  
  142.   
  143.     }  
  144. }  

针对用户的每个动作，我们考虑了在任何状态下发生，并做了一定处理。下面进行一些测试：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status;  
  2.   
  3. public class TestTra  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         VendingMachine machine = new VendingMachine(10);  
  8.         machine.insertMoney();  
  9.         machine.backMoney();  
  10.   
  11.         System.out.println("-----------");  
  12.   
  13.         machine.insertMoney();  
  14.         machine.turnCrank();  
  15.           
  16.         System.out.println("----------压力测试-----");  
  17.         machine.insertMoney();  
  18.         machine.insertMoney();  
  19.         machine.turnCrank();  
  20.         machine.turnCrank();  
  21.         machine.backMoney();  
  22.         machine.turnCrank();  
  23.   
  24.     }  
  25. }  
输出结果：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. 成功投入硬币  
  2. 退币成功  
  3. -----------  
  4. 成功投入硬币  
  5. 正在出商品....  
  6. 发出商品...  
  7. ----------压力测试-----  
  8. 成功投入硬币  
  9. 已经有硬币，无需投币  
  10. 正在出商品....  
  11. 发出商品...  
  12. 请先投入硬币  
  13. 您未投入硬币  
  14. 请先投入硬币  
感觉还是不错的，基本实现了功能，但是有些事情是不可避免的，那就是需求的变化，现在为了提升销量，当用户每次转动手柄买商品的时候，有10%的几率赠送一瓶。

现在的状态图发生了变化，当用户转动手柄时，可能会达到一个中奖的状态：图如下：

如果在我们刚写的代码上直接添加，则需要在每个动作的switch中添加判断条件，且非常容易出错。所以现在我们要考虑重新设计我们的代码，我们考虑把每个状态写状态类，负责实现在对应动作下的行为，然后自动售货机在不能的状态间切换：

下面开始重构，我们现在有5种状态，对应4个动作（投币、退币、转动手柄、发出商品），下面首先定义一个状态的超类型：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. /** 
  4.  * 状态的接口 
  5.  * @author zhy 
  6.  * 
  7.  */  
  8. public interface State  
  9. {  
  10.     /** 
  11.      * 放钱 
  12.      */  
  13.     public void insertMoney();  
  14.     /** 
  15.      * 退钱 
  16.      */  
  17.     public void backMoney();  
  18.     /** 
  19.      * 转动曲柄 
  20.      */  
  21.     public void turnCrank();  
  22.     /** 
  23.      * 出商品 
  24.      */  
  25.     public void dispense();  
  26. }  

然后分别是每个状态的实现：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. /** 
  4.  * 没钱的状态 
  5.  * @author zhy 
  6.  * 
  7.  */  
  8. public class NoMoneyState implements State  
  9. {  
  10.   
  11.     private VendingMachine machine;  
  12.   
  13.     public NoMoneyState(VendingMachine machine)  
  14.     {  
  15.         this.machine = machine;  
  16.           
  17.     }  
  18.       
  19.     @Override  
  20.     public void insertMoney()  
  21.     {  
  22.         System.out.println("投币成功");  
  23.         machine.setState(machine.getHasMoneyState());  
  24.     }  
  25.   
  26.     @Override  
  27.     public void backMoney()  
  28.     {  
  29.         System.out.println("您未投币，想退钱？...");  
  30.     }  
  31.   
  32.     @Override  
  33.     public void turnCrank()  
  34.     {  
  35.         System.out.println("您未投币，想拿东西么？...");  
  36.     }  
  37.   
  38.     @Override  
  39.     public void dispense()  
  40.     {  
  41.         throw new IllegalStateException("非法状态！");  
  42.     }  
  43.   
  44. }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. import java.util.Random;  
  4.   
  5. /** 
  6.  * 已投入钱的状态 
  7.  *  
  8.  * @author zhy 
  9.  *  
  10.  */  
  11. public class HasMoneyState implements State  
  12. {  
  13.   
  14.     private VendingMachine machine;  
  15.     private Random random = new Random();  
  16.   
  17.     public HasMoneyState(VendingMachine machine)  
  18.     {  
  19.         this.machine = machine;  
  20.     }  
  21.   
  22.     @Override  
  23.     public void insertMoney()  
  24.     {  
  25.         System.out.println("您已经投过币了，无需再投....");  
  26.     }  
  27.   
  28.     @Override  
  29.     public void backMoney()  
  30.     {  
  31.         System.out.println("退币成功");  
  32.   
  33.         machine.setState(machine.getNoMoneyState());  
  34.     }  
  35.   
  36.     @Override  
  37.     public void turnCrank()  
  38.     {  
  39.         System.out.println("你转动了手柄");  
  40.         int winner = random.nextInt(10);  
  41.         if (winner == 0 && machine.getCount() > 1)  
  42.         {  
  43.             machine.setState(machine.getWinnerState());  
  44.         } else  
  45.         {  
  46.             machine.setState(machine.getSoldState());  
  47.         }  
  48.     }  
  49.   
  50.     @Override  
  51.     public void dispense()  
  52.     {  
  53.         throw new IllegalStateException("非法状态！");  
  54.     }  
  55.   
  56. }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. /** 
  4.  * 售罄的状态 
  5.  *  
  6.  * @author zhy 
  7.  *  
  8.  */  
  9. public class SoldOutState implements State  
  10. {  
  11.   
  12.     private VendingMachine machine;  
  13.   
  14.     public SoldOutState(VendingMachine machine)  
  15.     {  
  16.         this.machine = machine;  
  17.     }  
  18.   
  19.     @Override  
  20.     public void insertMoney()  
  21.     {  
  22.         System.out.println("投币失败，商品已售罄");  
  23.     }  
  24.   
  25.     @Override  
  26.     public void backMoney()  
  27.     {  
  28.         System.out.println("您未投币，想退钱么？...");  
  29.     }  
  30.   
  31.     @Override  
  32.     public void turnCrank()  
  33.     {  
  34.         System.out.println("商品售罄，转动手柄也木有用");  
  35.     }  
  36.   
  37.     @Override  
  38.     public void dispense()  
  39.     {  
  40.         throw new IllegalStateException("非法状态！");  
  41.     }  
  42.   
  43. }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. /** 
  4.  * 准备出商品的状态,该状态下，不会有任何用户的操作 
  5.  *  
  6.  * @author zhy 
  7.  *  
  8.  */  
  9. public class SoldState implements State  
  10. {  
  11.   
  12.     private VendingMachine machine;  
  13.   
  14.     public SoldState(VendingMachine machine)  
  15.     {  
  16.         this.machine = machine;  
  17.     }  
  18.   
  19.     @Override  
  20.     public void insertMoney()  
  21.     {  
  22.         System.out.println("正在出货，请勿投币");  
  23.     }  
  24.   
  25.     @Override  
  26.     public void backMoney()  
  27.     {  
  28.         System.out.println("正在出货，没有可退的钱");  
  29.     }  
  30.   
  31.     @Override  
  32.     public void turnCrank()  
  33.     {  
  34.         System.out.println("正在出货，请勿重复转动手柄");  
  35.     }  
  36.   
  37.     @Override  
  38.     public void dispense()  
  39.     {  
  40.         machine.dispense();  
  41.         if (machine.getCount() > 0)  
  42.         {  
  43.             machine.setState(machine.getNoMoneyState());  
  44.         } else  
  45.         {  
  46.             System.out.println("商品已经售罄");  
  47.             machine.setState(machine.getSoldOutState());  
  48.         }  
  49.     }  
  50. }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. /** 
  4.  * 中奖的状态，该状态下不会有任何用户的操作 
  5.  *  
  6.  * @author zhy 
  7.  *  
  8.  */  
  9. public class WinnerState implements State  
  10. {  
  11.   
  12.     private VendingMachine machine;  
  13.   
  14.     public WinnerState(VendingMachine machine)  
  15.     {  
  16.         this.machine = machine;  
  17.     }  
  18.   
  19.     @Override  
  20.     public void insertMoney()  
  21.     {  
  22.         throw new IllegalStateException("非法状态");  
  23.     }  
  24.   
  25.     @Override  
  26.     public void backMoney()  
  27.     {  
  28.         throw new IllegalStateException("非法状态");  
  29.     }  
  30.   
  31.     @Override  
  32.     public void turnCrank()  
  33.     {  
  34.         throw new IllegalStateException("非法状态");  
  35.     }  
  36.   
  37.     @Override  
  38.     public void dispense()  
  39.     {  
  40.         System.out.println("你中奖了，恭喜你，将得到2件商品");  
  41.         machine.dispense();  
  42.   
  43.         if (machine.getCount() == 0)  
  44.         {  
  45.             System.out.println("商品已经售罄");  
  46.             machine.setState(machine.getSoldOutState());  
  47.         } else  
  48.         {  
  49.             machine.dispense();  
  50.             if (machine.getCount() > 0)  
  51.             {  
  52.                 machine.setState(machine.getNoMoneyState());  
  53.             } else  
  54.             {  
  55.                 System.out.println("商品已经售罄");  
  56.                 machine.setState(machine.getSoldOutState());  
  57.             }  
  58.               
  59.         }  
  60.   
  61.     }  
  62.   
  63. }  


最后是自动售货机的代码：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. /** 
  4.  * 自动售货机 
  5.  *  
  6.  * @author zhy 
  7.  *  
  8.  */  
  9. public class VendingMachine  
  10. {  
  11.     private State noMoneyState;  
  12.     private State hasMoneyState;  
  13.     private State soldState;  
  14.     private State soldOutState;  
  15.     private State winnerState ;   
  16.   
  17.     private int count = 0;  
  18.     private State currentState = noMoneyState;  
  19.   
  20.     public VendingMachine(int count)  
  21.     {  
  22.         noMoneyState = new NoMoneyState(this);  
  23.         hasMoneyState = new HasMoneyState(this);  
  24.         soldState = new SoldState(this);  
  25.         soldOutState = new SoldOutState(this);  
  26.         winnerState = new WinnerState(this);  
  27.   
  28.         if (count > 0)  
  29.         {  
  30.             this.count = count;  
  31.             currentState = noMoneyState;  
  32.         }  
  33.     }  
  34.   
  35.     public void insertMoney()  
  36.     {  
  37.         currentState.insertMoney();  
  38.     }  
  39.   
  40.     public void backMoney()  
  41.     {  
  42.         currentState.backMoney();  
  43.     }  
  44.   
  45.     public void turnCrank()  
  46.     {  
  47.         currentState.turnCrank();  
  48.         if (currentState == soldState || currentState == winnerState)  
  49.             currentState.dispense();  
  50.     }  
  51.   
  52.     public void dispense()  
  53.     {  
  54.         System.out.println("发出一件商品...");  
  55.         if (count != 0)  
  56.         {  
  57.             count -= 1;  
  58.         }  
  59.     }  
  60.   
  61.     public void setState(State state)  
  62.     {  
  63.         this.currentState = state;  
  64.     }  
  65.   
  66.     //getter setter omitted ...  
  67.   
  68. }  

可以看到，我们现在把每个状态对应于动作的行为局部化到了状态自己的类中实现，不仅增加了扩展性而且使代码的阅读性大幅度的提高。以后再添加状态，只需要针对新添加的状态的实现类，并在自动售货机中添加此状态即可。

下面进行一些测试：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.status.b;  
  2.   
  3. public class Test  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         VendingMachine machine = new VendingMachine(10);  
  8.         machine.insertMoney();  
  9.         machine.backMoney();  
  10.   
  11.         System.out.println("----我要中奖----");  
  12.   
  13.         machine.insertMoney();  
  14.         machine.turnCrank();  
  15.         machine.insertMoney();  
  16.         machine.turnCrank();  
  17.         machine.insertMoney();  
  18.         machine.turnCrank();  
  19.         machine.insertMoney();  
  20.         machine.turnCrank();  
  21.         machine.insertMoney();  
  22.         machine.turnCrank();  
  23.         machine.insertMoney();  
  24.         machine.turnCrank();  
  25.         machine.insertMoney();  
  26.         machine.turnCrank();  
  27.   
  28.         System.out.println("-------压力测试------");  
  29.   
  30.         machine.insertMoney();  
  31.         machine.backMoney();  
  32.         machine.backMoney();  
  33.         machine.turnCrank();// 无效操作  
  34.         machine.turnCrank();// 无效操作  
  35.         machine.backMoney();  
  36.   
  37.     }  
  38. }  

输出结果：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. 投币成功  
  2. 退币成功  
  3. ----我要中奖----  
  4. 投币成功  
  5. 你转动了手柄  
  6. 发出一件商品...  
  7. 投币成功  
  8. 你转动了手柄  
  9. 发出一件商品...  
  10. 投币成功  
  11. 你转动了手柄  
  12. 发出一件商品...  
  13. 投币成功  
  14. 你转动了手柄  
  15. 发出一件商品...  
  16. 投币成功  
  17. 你转动了手柄  
  18. 发出一件商品...  
  19. 投币成功  
  20. 你转动了手柄  
  21. 发出一件商品...  
  22. 投币成功  
  23. 你转动了手柄  
  24. 你中奖了，恭喜你，将得到2件商品  
  25. 发出一件商品...  
  26. 发出一件商品...  
  27. -------压力测试------  
  28. 投币成功  
  29. 退币成功  
  30. 您未投币，想退钱？...  
  31. 您未投币，想拿东西么？...  
  32. 您未投币，想拿东西么？...  
  33. 您未投币，想退钱？...  

恭喜你，又学会了一个设计模式，状态模式。最后看下状态模式的类图：


yehexing3
关注
专栏目录
UML 自动售货机的设计_状态图描述
05-22
uml中的设计部分，用状态图描述 讲述自动售货机的原理和状态转换
设计模式 状态模式 以自动售货机为例
weixin_30555753的博客
05-20 611
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/26350617状态模式给了我眼前一亮的感觉啊，值得学习~先看定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。定义又开始模糊了，理一下，当对象的内部状态改变时，它的行为跟随状态的改变而改变了，看起来好像重新初始化了一个类似的。下面使用个例子来说明状态模式的...
Unity 设计模式 之 行为型模式 -【状态模式】【观察者模式】【备忘录模式】
最新发布
仙魁XAN
09-23 1246
设计模式是指在软件开发中为解决常见问题而总结出的一套可复用的解决方案。这些模式是经过长期实践证明有效的编程经验总结，并可以在不同的项目中复用。设计模式并不是代码片段，而是对常见问题的抽象解决方案，它提供了代码结构和模块间交互的一种设计思路，帮助开发者解决特定的设计问题。设计模式的特点：通用性：设计模式针对的是软件开发中常见的设计问题，适用于各种软件工程项目。可复用性：设计模式可以在不同项目和环境下被重复使用，提高代码的可维护性和扩展性。可扩展性：设计模式有助于让代码结构更加灵活，易于扩展和修改。
状态模式--自动售货机
qwqc262的博客
11-04 635
状态模式–自动售货机 咖啡自动售货机共有3种状态，分别是“有咖啡，无人投币”、“有咖啡，有人投币”和“无咖啡”。咖啡自动售货机有两个方法：needAnCoin( )和sellCoffee( )。 咖啡自动售货机的默认初始状态是“有咖啡，无人投币”。当咖啡自动售货机处于“有咖啡，无人投币”状态时，调用sellCoffee( )方法将显示“需投一元硬币，才可以得到一杯咖啡”，并保持当前的状态；调用needAnCoin( )方法将显示“咖啡机里被投入了一元硬币”，然后咖啡自动售货机将处于“有咖啡，有人投币”状态，
uml 自动售货机报告 状态图 源码
06-14
兔宝宝牌伪界面版自动售货机1.0版本。 实现基本的买，找零，统计功能。
状态机设计模式，实现一个自动售货机的状态机
舒航的博客
07-27 2552
心血来潮写一篇关于状态机的文章，在学习状态机模式的时候最被熟悉的例子应该是自动售货机，所以就用自动售货机来写一篇状态机的文章吧。 首先分析自动售货机的状态，初步设计状态有初始化、商品选择中、出货中，有投币、退钱、锁定商品、出货成功事件，根据这几个状态和事件，设计了如下初步状态机图。 状态机图如上，接下来进入编码阶段。首先要确定的就是某个状态能处理哪些事件，某个状态收到某个事件可以去到哪个状态。开始状态只可以进行投币操作去到商品选择状态。商品选择状态只能锁定商品去到出货中状态或者重新回到商品选择状态.
Java自动售货机实验报告,java案例自动售货机
weixin_36269724的博客
03-16 1793
组态王实验案例——全自动售货机_信息与通信_工程科技_专业资料。西门子plc与组态王的实验案例 全自动售货机操作步骤 1.新建工程,命名为全自动售货机 2.设备\\......脚本是系统的 用例的实例称为脚本 一次具体执行过程。 一次具体执行过程。 例如, 例如, 在自动售货机系统中, 在自动售货机系统中,张三投入硬币购买矿泉 系统收......测试用例设计自动售货机因果图分析_计算机软件及应用_...
糖果售货机状态模式实例解析
3. **举例**：通过一个糖果自动售货机的例子，展示了状态模式的应用。机器有多种状态，如没有25分钱、有25分钱、投入25分钱等，每个状态对应不同的操作，如接收硬币、发放糖果等。 4. **代码实现**：通过将状态编码...
设计模式之 状态模式 以自动售货机为例
weixin_39113426的博客
11-30 277
先看定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。定义又开始模糊了，理一下，当对象的内部状态改变时，它的行为跟随状态的改变而改变了，看起来好像重新初始化了一个类似的。 下面使用个例子来说明状态模式的用法，现在有个自动售货机的代码需要我们来写，状态图如下： 分析一个这个状态图： a、包含4个状态（我们使用4个int型常量来表示） b、包含
软件工程课程设计【自动售货机】.docx
06-18
在本软件工程课程设计中，学生们将面临一个实际的项目挑战——开发一款自动售货机系统。这个项目旨在让学生们运用所学的软件工程理论知识，包括需求分析、设计、实现和测试等阶段，来创建一个能够模拟真实世界中自动...
《Java程序小作业之自动贩卖机》#谭子
tanz10086的博客
03-03 8609
第一次写博客有点小小紧张哈，刚入门Java这门语言没多久，博主现在还在打基础中。这里为大伙们分享一下程序课的模拟作业，大概内容也不是很多，图一乐看个热闹就好了，如果需要借鉴的话，当然可以把这里的源码拿去玩玩的。就是，我们最后还有部分Bug问题没解决，就，图一乐吧！ 开学第一周是实训周，我们这边给到的题目的是整一个自动贩卖机的模拟，给了五天的作业时间，2天就已经写好了大致内容了，后面又花了3天在补Bug，最后勉强把论文报告的字数凑满。下面是我们课题组最后整的活。 一、设计思路 本方案设计...
3-状态模式
文白的博客
03-16 521
状态模式（状态对象）允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
IC学习笔记：02.自动售货饮料-有限状态机-mealy型
weixin_56245975的博客
12-28 2119
第一步：看要求 编写一个自动售货机，功能如下： 1）共有三种纸币入口，分别支持10元，20元，50元； 2）货物售价为80元； 3）需要支持找钱功能（注意，找钱有四种种情况）。 RTL编码，完成testbench编码，用QuestaSim仿真波形通过。 答题 第一步画出状态转移图 有7种状态，状态图从s0到s7如下图 第二步：辨别情况，设置输入输出及s0~s7的状态 （1）输入与输出状态 设置投钱10元为：in10, 设置投钱20元为：in20, 设置投钱50元为：in50 设置出货为：out, 设置找钱
状态机——简单自动售卖机的实现
ziyouruf的博客
03-16 2728
状态机也称为同步有限状态机，分为more型状态机（最后的输出只与当前状态有关，而与输入无关）和mealy型状态机（最后的输出不仅与当前状态有关，还与输入有），适合用来表示事件发生有先后顺序的情况。这里以可乐机为背景，可乐售价为3元/瓶，一元一元投币，每投入到3元自动出一瓶可乐。 这里设置的输入信号包括时钟sys_clk，复位sys_rst_n以及投币信号pi_money，输出为是否有可乐投出po_cola。 首先绘制一个状态转移图，在状态转移图上可以清楚地表达出各状态的输入输出，跳转的条件和功能，一个完
超全画图攻略（9207）
m0_64848611的博客
12-13 730
医院对患者监护系统的基本要求是随时接收每个病人的生理信号（脉搏、体温、血压、心电图等），定时记录病人情况，以形成患者日志。一个饮料自动售货机可以放置五种不同或部分相同的饮料，可由厂商根据销售状况自动调配，并可随时重新设置售价，但售货机最多仅能放置50罐饮料，其按钮设计在各种饮料样本的下方，若经金额计算器累计金额足够，则选择键灯会亮；3.Flight类和Plane类之间时一个双向关联的类图如下图所示，请根据类图模型，描述一架NX0337客机的两次飞行情况，并用对象图将其表述出来。
有限状态自动机
yake1965
08-18 875
状态机 状态机是有限状态自动机的简称，是现实事物运行规则抽象而成的一个数学模型。 “状态”（ State ） 现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed 。 状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换图。例如，根据自动门的运行规则，我们可以抽象出下面这么一个图。 自动
设计模式浅析(十一) ·状态模式
Jerrylau213的博客
04-08 893
设计模式浅析(十一) ·状态模式
饮料售货机——状态机
hu491199877的博客
04-01 1358
verilog 饮料售卖机
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值