查看: 237|回复: 0

[Java代码] Java使用备忘录模式实现过关类游戏功能详解

发表于 2018-5-6 09:00:10

本文实例讲述了Java使用备忘录模式实现过关类游戏功能。分享给大家供大家参考,具体如下:

一.模式定义

备忘录模式,在不破坏封闭的前提下,捕获一个对象的内部状态,并在该对象外部保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

二.模式举例

1模式分析

我们借用过关类游戏来说明这一模式。

2备忘录模式静态类图

3代码示例(黑箱备忘录模式)

3.1创建备忘录窄接口一INarrowMemento

  1. package com.demo.memento;
  2. /**
  3. * 备忘录窄接口(不提供任何方法,外部对象不能访问备忘录对象内部信息)
  4. *
  5. * @author
  6. *
  7. */
  8. public interface INarrowMemento {
  9. }
复制代码

3.2备忘录发起者一Hero

  1. package com.demo.originator;
  2. import java.util.Random;
  3. import com.demo.memento.INarrowMemento;
  4. /**
  5. * 挑战者
  6. *
  7. * @author
  8. *
  9. */
  10. public class Hero {
  11. // 血液值
  12. private int blood;
  13. // 武力值
  14. private int sword;
  15. // 随机数
  16. private final Random random = new Random();
  17. // 构造方法初始化 内容
  18. public Hero() {
  19. this.blood = 100;
  20. this.sword = 100;
  21. }
  22. // 创建备忘录保存内容
  23. public INarrowMemento createMemento() {
  24. System.out.println("创建备忘录...");
  25. return new Memento(this.blood, this.sword);
  26. }
  27. // 恢复备忘录内容
  28. public void restoreFromMemento(INarrowMemento memento) {
  29. System.out.println("恢复备忘录中的状态...");
  30. if (memento != null) {
  31. Memento memento2 = (Memento) memento;
  32. this.blood = memento2.getBlood();
  33. this.sword = memento2.getSword();
  34. }
  35. }
  36. /**
  37. * 挑战BOSS
  38. */
  39. public int koBoss() {
  40. // 当血液值<=0 时 挑战失败 假设战胜BOSS的概率为2%
  41. // 判断时候还有血液值
  42. if (this.blood <= 0 || this.sword <= 0) {
  43. System.out.println(this.toString());
  44. System.out.println("挑战BOSS失败!");
  45. return -1;
  46. } else {
  47. // 获得随机数
  48. double win = Math.random();
  49. if (win <= 0.02) {
  50. System.out.println(this.toString());
  51. System.out.println("恭喜你,挑战BOSS成功!");
  52. return 1;
  53. } else {
  54. System.out.println(this.toString());
  55. System.out.println("继续攻击BOSS...");
  56. // 随机数减少血液值和武力值 继续KO
  57. int blood_sub = random.nextInt(10);
  58. int sword_sub = random.nextInt(10);
  59. this.blood -= blood_sub;
  60. this.sword -= sword_sub;
  61. return 0;
  62. }
  63. }
  64. }
  65. @Override
  66. public String toString() {
  67. return "当前血液值:" + this.blood + " - 当前武力值:" + this.sword;
  68. }
  69. /**
  70. * 备忘录(整个类都是私有的,只有发起者才能访问)
  71. *
  72. * @author
  73. *
  74. */
  75. private class Memento implements INarrowMemento {
  76. // 血液值
  77. private final int blood;
  78. // 武力值
  79. private final int sword;
  80. // 构造方法初始化 内容
  81. private Memento(int blood, int sword) {
  82. this.blood = blood;
  83. this.sword = sword;
  84. }
  85. private int getBlood() {
  86. return blood;
  87. }
  88. private int getSword() {
  89. return sword;
  90. }
  91. }
  92. }
复制代码

3.3备忘录管理者一Caretaker

  1. package com.demo.caretaker;
  2. import com.demo.memento.INarrowMemento;
  3. /**
  4. * 管理者
  5. *
  6. * @author
  7. *
  8. */
  9. public class Caretaker {
  10. private INarrowMemento memento;
  11. /**
  12. * 获得备忘录对象
  13. *
  14. * @return
  15. */
  16. public INarrowMemento getMemento() {
  17. return memento;
  18. }
  19. /**
  20. * 保存备忘录对象
  21. *
  22. * @param memento
  23. */
  24. public void setMemento(INarrowMemento memento) {
  25. this.memento = memento;
  26. }
  27. }
复制代码

3.4让英雄挑战Boss一Client

  1. package com.demo;
  2. import com.demo.caretaker.Caretaker;
  3. import com.demo.originator.Hero;
  4. /**
  5. * 客户端主应用程序
  6. *
  7. * @author
  8. *
  9. */
  10. public class Client {
  11. /**
  12. * @param args
  13. */
  14. public static void main(String[] args) {
  15. // 创建角色
  16. Hero hero = new Hero();
  17. // 创建管理者
  18. Caretaker caretaker = new Caretaker();
  19. // 保存挑战前的状态信息
  20. caretaker.setMemento(hero.createMemento());
  21. // 只有三次战胜BOSS的机会
  22. int cnt = 1;
  23. // 挑战BOSS结果
  24. int ko = -1;
  25. while (ko != 1 && cnt <= 3) {
  26. System.out
  27. .println("=============== 第" + cnt + "次挑战 ==============");
  28. // 开始挑战BOSS
  29. ko = hero.koBoss();
  30. while (true) {
  31. if (ko == -1) {
  32. // 挑战失败 恢复到初始状态 累加挑战次数
  33. hero.restoreFromMemento(caretaker.getMemento());
  34. cnt += 1;
  35. break;
  36. } else if (ko == 0) {
  37. // 继续挑战
  38. ko = hero.koBoss();
  39. } else if (ko == 1) {
  40. // 挑战成功!
  41. break;
  42. }
  43. }
  44. }
  45. }
  46. }
复制代码

4运行结果

创建备忘录...
=============== 第1次挑战 ==============
当前血液值:100 - 当前武力值:100
继续攻击BOSS...
当前血液值:96 - 当前武力值:99
继续攻击BOSS...
当前血液值:90 - 当前武力值:98
继续攻击BOSS...
当前血液值:81 - 当前武力值:95
继续攻击BOSS...
当前血液值:78 - 当前武力值:93
继续攻击BOSS...
当前血液值:72 - 当前武力值:88
继续攻击BOSS...
当前血液值:64 - 当前武力值:85
继续攻击BOSS...
当前血液值:56 - 当前武力值:80
继续攻击BOSS...
当前血液值:49 - 当前武力值:73
继续攻击BOSS...
当前血液值:45 - 当前武力值:71
继续攻击BOSS...
当前血液值:37 - 当前武力值:68
继续攻击BOSS...
当前血液值:29 - 当前武力值:65
继续攻击BOSS...
当前血液值:20 - 当前武力值:59
继续攻击BOSS...
当前血液值:11 - 当前武力值:54
继续攻击BOSS...
当前血液值:9 - 当前武力值:52
继续攻击BOSS...
当前血液值:3 - 当前武力值:45
继续攻击BOSS...
当前血液值:-3 - 当前武力值:41
挑战BOSS失败!
恢复备忘录中的状态...
=============== 第2次挑战 ==============
当前血液值:100 - 当前武力值:100
继续攻击BOSS...
当前血液值:96 - 当前武力值:95
继续攻击BOSS...
当前血液值:96 - 当前武力值:91
继续攻击BOSS...
当前血液值:88 - 当前武力值:82
继续攻击BOSS...
当前血液值:79 - 当前武力值:79
继续攻击BOSS...
当前血液值:76 - 当前武力值:72
继续攻击BOSS...
当前血液值:73 - 当前武力值:70
继续攻击BOSS...
当前血液值:72 - 当前武力值:66
继续攻击BOSS...
当前血液值:72 - 当前武力值:61
继续攻击BOSS...
当前血液值:72 - 当前武力值:58
继续攻击BOSS...
当前血液值:72 - 当前武力值:52
继续攻击BOSS...
当前血液值:63 - 当前武力值:51
继续攻击BOSS...
当前血液值:62 - 当前武力值:50
继续攻击BOSS...
当前血液值:54 - 当前武力值:41
继续攻击BOSS...
当前血液值:50 - 当前武力值:39
继续攻击BOSS...
当前血液值:47 - 当前武力值:39
继续攻击BOSS...
当前血液值:43 - 当前武力值:38
继续攻击BOSS...
当前血液值:37 - 当前武力值:36
继续攻击BOSS...
当前血液值:34 - 当前武力值:35
继续攻击BOSS...
当前血液值:32 - 当前武力值:27
继续攻击BOSS...
当前血液值:28 - 当前武力值:22
继续攻击BOSS...
当前血液值:26 - 当前武力值:15
继续攻击BOSS...
当前血液值:24 - 当前武力值:11
继续攻击BOSS...
当前血液值:19 - 当前武力值:3
继续攻击BOSS...
当前血液值:10 - 当前武力值:-3
挑战BOSS失败!
恢复备忘录中的状态...
=============== 第3次挑战 ==============
当前血液值:100 - 当前武力值:100
继续攻击BOSS...
当前血液值:99 - 当前武力值:93
继续攻击BOSS...
当前血液值:98 - 当前武力值:84
继续攻击BOSS...
当前血液值:98 - 当前武力值:82
继续攻击BOSS...
当前血液值:95 - 当前武力值:76
继续攻击BOSS...
当前血液值:88 - 当前武力值:68
继续攻击BOSS...
当前血液值:81 - 当前武力值:64
继续攻击BOSS...
当前血液值:76 - 当前武力值:64
继续攻击BOSS...
当前血液值:67 - 当前武力值:64
恭喜你,挑战BOSS成功!

三. 该模式设计原则

1封装边界的保持
2双重接口实现,保证安全性。

四. 使用场合

1需要在某一时刻恢复一个对象先前的状态时。
2白箱备忘录模式,需要在外部保存对象某一时刻的状态,但如果用一个接口来让其他对象直接得到这些状态,将会暴露对象的实现细节并破坏对象的封装性。
3黑箱备忘录模式实现方式提供了双重接口访问机制,对发起者对象提供宽接口,而对发起者以外的对象提供窄接口,从而有效解决了封装性和安全性。

五. 静态类图

1白箱备忘录模式静态类图

2黑箱备忘录模式静态类图

更多java相关内容感兴趣的读者可查看本站专题:《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。



回复

使用道具 举报