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

最新推荐文章于 2022-04-01 01:24:06 发布
最新推荐文章于 2022-04-01 01:24:06 发布
阅读量977 收藏 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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自动贩卖机的实现和状态机图
06-29
UML自动售货机的设计 自动售货机的设计用状态图描述 时间时间： 每一个状态都包含一个内部的计时器 进入每一个状态的时候计时器都会被重置 超过规定时间没有操作，系统退回所有已经输入的硬币然后进入空闲状态 活动状态： 表示对象执行某些内部处理的一段时间 只要顾客对一个交易的输入一旦完成，活动状态就成为激活的，对应于机器计算它是都能够返回为完成该交易所需要找的零钱
设计模式 状态模式 以自动售货机为例
weixin_30555753的博客
05-20 560
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/26350617状态模式给了我眼前一亮的感觉啊，值得学习~先看定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。定义又开始模糊了，理一下，当对象的内部状态改变时，它的行为跟随状态的改变而改变了，看起来好像重新初始化了一个类似的。下面使用个例子来说明状态模式的...
状态模式--自动售货机
qwqc262的博客
11-04 559
状态模式–自动售货机 咖啡自动售货机共有3种状态，分别是“有咖啡，无人投币”、“有咖啡，有人投币”和“无咖啡”。咖啡自动售货机有两个方法：needAnCoin( )和sellCoffee( )。 咖啡自动售货机的默认初始状态是“有咖啡，无人投币”。当咖啡自动售货机处于“有咖啡，无人投币”状态时，调用sellCoffee( )方法将显示“需投一元硬币，才可以得到一杯咖啡”，并保持当前的状态；调用needAnCoin( )方法将显示“咖啡机里被投入了一元硬币”，然后咖啡自动售货机将处于“有咖啡，有人投币”状态，
状态机设计模式，实现一个自动售货机的状态机
舒航的博客
07-27 2279
心血来潮写一篇关于状态机的文章，在学习状态机模式的时候最被熟悉的例子应该是自动售货机，所以就用自动售货机来写一篇状态机的文章吧。 首先分析自动售货机的状态，初步设计状态有初始化、商品选择中、出货中，有投币、退钱、锁定商品、出货成功事件，根据这几个状态和事件，设计了如下初步状态机图。 状态机图如上，接下来进入编码阶段。首先要确定的就是某个状态能处理哪些事件，某个状态收到某个事件可以去到哪个状态。开始状态只可以进行投币操作去到商品选择状态。商品选择状态只能锁定商品去到出货中状态或者重新回到商品选择状态.
状态机——饮料自动售货机
carrot_guo的博客
04-30 5916
一、 状态模式概述 1.1 什么是状态模式 状态模式是在不同状态下，执行相同的方法，具有不同的实现方式。而每个不同的状态会被封装为一个类，这个类实现了不同状态间共同的方法，只是方法的实现方式各不相同。同时所有状态会被保存在一个状态机器中，状态机器在执行某个操作时，会调用状态的方法来执行操作，具体操作是如何状态机器是不会知道的。因此机器可以直接根据状态执行动作，当状态切换时，动作的执行内容也会跟着状...
嵌入式课程设计 自动售货机系统设计.doc
01-09
嵌入式课程设计 自动售货机系统设计
基于西门子PLC设计的自动售货机系统
07-26
基于西门子PLC设计的自动售货机系统
PLC自动售货机程序设计.doc
12-21
PLC自动售货机程序设计.doc
基于嵌入式的自动售货机设计与实现
01-19
随着电子技术不断的发展，很多智能化设备逐步取代了人工劳动，自动售货机就是其中一种基于嵌入式系统的智能化设备（什么是嵌入式系统），对于嵌入式系统设计实例，小编就以自动售货机软硬件设计为例，来简单对嵌入式...
基于VHDL实现的自动售货机芯片设计
01-28
此设计使用VHDL语言实现了一种自动售货机芯片，该芯片能够设定多种商品和货币的交易模式，并智能精确地完成交易过程。经MAXPLUS II进行仿真实验表明该设计具有设计全面、功能完善、交易准确等特点，达到了设计要求。
uml 自动售货机报告 状态图 源码
06-14
兔宝宝牌伪界面版自动售货机1.0版本。 实现基本的买，找零，统计功能。
自动售货机源码+使用说明+状态机图.rar
05-23
自动售货机源码 使用说明 状态机图 uml作业 杭电软件工程
UML 自动售货机的设计_状态图描述
05-22
uml中的设计部分，用状态图描述 讲述自动售货机的原理和状态转换
《Java程序小作业之自动贩卖机》#谭子
tanz10086的博客
03-03 8228
第一次写博客有点小小紧张哈，刚入门Java这门语言没多久，博主现在还在打基础中。这里为大伙们分享一下程序课的模拟作业，大概内容也不是很多，图一乐看个热闹就好了，如果需要借鉴的话，当然可以把这里的源码拿去玩玩的。就是，我们最后还有部分Bug问题没解决，就，图一乐吧！ 开学第一周是实训周，我们这边给到的题目的是整一个自动贩卖机的模拟，给了五天的作业时间，2天就已经写好了大致内容了，后面又花了3天在补Bug，最后勉强把论文报告的字数凑满。下面是我们课题组最后整的活。 一、设计思路 本方案设计...
IC学习笔记：02.自动售货饮料-有限状态机-mealy型
weixin_56245975的博客
12-28 1923
第一步：看要求 编写一个自动售货机，功能如下： 1）共有三种纸币入口，分别支持10元，20元，50元； 2）货物售价为80元； 3）需要支持找钱功能（注意，找钱有四种种情况）。 RTL编码，完成testbench编码，用QuestaSim仿真波形通过。 答题 第一步画出状态转移图 有7种状态，状态图从s0到s7如下图 第二步：辨别情况，设置输入输出及s0~s7的状态 （1）输入与输出状态 设置投钱10元为：in10, 设置投钱20元为：in20, 设置投钱50元为：in50 设置出货为：out, 设置找钱
饮料售货机——状态机
hu491199877的博客
04-01 1143
verilog 饮料售卖机
自动售货机 顺序图_饮料自动售货机系统的分析与设计
weixin_42343756的博客
12-30 4393
饮料自动售货机系统的分析与设计1.系统的分析1.1需求分析描述自动售货机像磁卡电话、银行柜员机一样，以方便、新颖、文明、昼夜服务等特点，成为便民配套设施。如今的自动售货机可以为顾客提供多种服务。顾客可以根据自己的需要选择商品并投入钱币，售货机接收钱币，售出商品。自动售货机是一种无人售货系统。售货时，顾客投入硬币，售货机进行真假币的检查，若是假币拒绝接收，若是有效硬币则进行累加。售货机装有若干个含有...
一段、两段及三段式状态机的写法——售货机的verilog实现
H19981118的博客
02-03 4291
状态机的Verilog写法，分类，编码方式以及各种实例
在线购物系统用况图
热门推荐
清陌的博客
06-14 1万+
一、用况图二、用况描述用况名：添加购物车商品简述：顾客有购买商品的意图，但是觉得需要考虑时，可执行添加购物车商品操作。参与者：消费者包含：无扩展：无继承：无前置条件：顾客必须登录成功。细节：在主页面，用户点击商品，进入商品介绍页面；在商品介绍页面，用户点击加入购物车，进入商品信息选择页面；物品信息选择页面，用户选择商品信息，点击确认，系统自动将物品加入购物车。后置条件：物品信息选择页面，商品信息必...
状态机实现自动售货机
最新发布
08-10
状态机是一种常用的实现自动售货机的方法。在状态机中，售货机的行为会根据当前的状态和输入进行相应的转换和处理。 首先，我们需要定义售货机的状态。常见的状态包括：待机状态、选择商品状态、投入硬币状态、购买...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值