第十九章 备忘录模式

19.1 基本介绍

1. 备忘录模式（Memento Pattern）在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态。
2. 可以这样理解备忘录模式：现实生活中的备忘录是用来记录某些要去做的事情，或者是记录已经达成的共同意见的事情，以防忘记了。而在软件层面，备忘录模式有着相同的含义，备忘录对象主要用来记录一个对象的某种状态或者某些数据，当要做回退时，可以从备忘录对象里获取原来的数据进行恢复操作。
3. 备忘录模式属于行为型模式。

19.2 角色及职责

• originator：对象（需要保存状态的对象）
• Memento ： 备忘录对象，负责保存好记录，即 Originator 内部状态
• Caretaker：守护者对象，负责保存多个备忘录对象， 使用集合管理，提高效率
  说明：如果希望保存多个 originator 对象的不同时间的状态也可以，只需要用 HashMap <String, 集合>

代码实现：

public class Originator {
   private String state;//状态信息
   public String getState() {
      return state;
   }
   public void setState(String state) {
      this.state = state;
   }   
   //编写一个方法，可以保存一个状态对象 Memento
   //因此编写一个方法，返回 Memento
   public Memento saveStateMemento() {
      return new Memento(state);
   }  
   //通过备忘录对象，恢复状态
   public void getStateFromMemento(Memento memento) {
      state = memento.getState();
   }
}

public class Memento {
   private String state;
   //构造器
   public Memento(String state) {
      super();
      this.state = state;
   }
   public String getState() {
      return state;
   }  
}

public class Caretaker {   
   //在List 集合中会有很多的备忘录对象
   private List<Memento> mementoList = new ArrayList<Memento>();
   //如果只保存一次状态
   // private Memento  memento;
    //对GameRole 保存多次状态
    //private ArrayList<Memento> mementos;
    //对多个游戏角色保存多个状态
    //private HashMap<String, ArrayList<Memento>> rolesMementos;
   
   public void add(Memento memento) {
      mementoList.add(memento);
   }   
   //获取到第 index 个 Originator 的备忘录对象(即保存状态)
   public Memento get(int index) {
      return mementoList.get(index);
   }
}

public class Client {
   public static void main(String[] args) {     
      Originator originator = new Originator();
      Caretaker caretaker = new Caretaker();
      
      originator.setState(" 状态#1 攻击力 100 ");     
      //保存了当前的状态
      caretaker.add(originator.saveStateMemento());
      
      originator.setState(" 状态#2 攻击力 80 ");      
      caretaker.add(originator.saveStateMemento());
    
      System.out.println("当前的状态是 =" + originator.getState());      
      //希望得到状态 1, 将 originator 恢复到状态1      
      originator.getStateFromMemento(caretaker.get(0));
      System.out.println("恢复到状态1 , 当前的状态是 =" + originator.getState()); 
   }
}

19.3 注意事项和细节

1. 给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。
2. 实现了信息的封装，使得用户不需要关心状态的保存细节。
3. 如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存, 这个需要注意。
4. 适用的应用场景：后悔药、打游戏时的存档、Windows 里的 ctri + z、IE 中的后退、数据库的事务管理。
5. 为了节约内存，备忘录模式可以和原型模式配合使用。

第二十章 解释器模式

20.1 基本介绍

1. 在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树，这里的词法分析器和语法分析器都可以看做是解释器。
2. 解释器模式（Interpreter Pattern）：是指给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）。
3. 应用场景
   • 应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
   • 一些重复出现的问题可以用一种简单的语言来表达
   • 一个简单语法需要解释的场景
   • 例子有编译器、运算表达式计算、正则表达式、机器人等

20.2 角色及职责

• Context：是环境角色,含有解释器之外的全局信息。
• AbstractExpression：抽象表达式， 声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享。
• TerminalExpression：为终结符表达式，实现与文法中的终结符相关的解释操作。
• NonTermialExpression：为非终结符表达式，为文法中的非终结符实现解释操作。
  说明： 输入 Context 和 TerminalExpression 信息通过 Client 输入即可

20.3 实例分析

通过解释器模式来实现四则运算，如计算 a+b-c 的值，具体要求：

1. 先输入表达式的形式，比如 a+b+c-d+e，要求表达式的字母不能重复
2. 再分别输入 a，b，c，d，e 的值
3. 最后输出计算结果

// 抽象类表达式，通过HashMap 键值对, 可以获取到变量的值
public abstract class Expression {
   // 解释公式和数值(a + b - c), key 就是公式(表达式) 参数[a,b,c], value就是就是具体值
   // HashMap {a=10, b=20}
   public abstract int interpreter(HashMap<String, Integer> var);
}

// 变量的解释器
public class VarExpression extends Expression {
   private String key; // key=a,key=b,key=c
   public VarExpression(String key) {
      this.key = key;
   }
   // interpreter 根据变量名称(var 就是{a=10, b=20})，返回对应值
   @Override
   public int interpreter(HashMap<String, Integer> var) {
      return var.get(this.key);
   }
}

// 抽象运算符号解析器,这里每个运算符号，都只和自己左右两个数字有关系，
// 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类
public class SymbolExpression extends Expression {
   protected Expression left;
   protected Expression right;
   public SymbolExpression(Expression left, Expression right) {
      this.left = left;
      this.right = right;
   }
   //因为 SymbolExpression 是让其子类来实现，因此 interpreter 是一个默认实现
   @Override
   public int interpreter(HashMap<String, Integer> var) {
      return 0;
   }
}

// 加法解释器
public class AddExpression extends SymbolExpression  {
   public AddExpression(Expression left, Expression right) {
      super(left, right);
   }
   //处理相加     var 仍然是 {a=10,b=20}..
   public int interpreter(HashMap<String, Integer> var) {
      //super.left.interpreter(var) ： 返回 left 表达式对应的值 a = 10
      //super.right.interpreter(var): 返回right 表达式对应值 b = 20
      return super.left.interpreter(var) + super.right.interpreter(var);
   }
}

// 减法解释器
public class SubExpression extends SymbolExpression {
   public SubExpression(Expression left, Expression right) {
      super(left, right);
   }
   //求出left 和 right 表达式相减后的结果
   public int interpreter(HashMap<String, Integer> var) {
      return super.left.interpreter(var) - super.right.interpreter(var);
   }
}

public class Calculator {
   // 定义表达式
   private Expression expression;
   // 构造函数传参，并解析
   public Calculator(String expStr) { // expStr = a+b
      // 安排运算先后顺序
      Stack<Expression> stack = new Stack<>();
      // 表达式拆分成字符数组 
      char[] charArray = expStr.toCharArray();// [a, +, b]

      Expression left = null;
      Expression right = null;
      //遍历字符数组， 即遍历  [a, +, b]    
      for (int i = 0; i < charArray.length; i++) {
         switch (charArray[i]) { //针对不同的情况，做处理
         case ‘+‘: //
            left = stack.pop();// 从stack取出left => "a"
            right = new VarExpression(String.valueOf(charArray[++i]));// 取出右表达式 "b"
            // 然后根据得到left 和 right 构建 AddExpresson加入stack
            stack.push(new AddExpression(left, right));
            break;
         case ‘-‘: // 
            left = stack.pop();
            right = new VarExpression(String.valueOf(charArray[++i]));
            stack.push(new SubExpression(left, right));
            break;
         default: 
            //如果是一个 Var 就创建一个 VarExpression 对象，并push到 stack
            stack.push(new VarExpression(String.valueOf(charArray[i])));
            break;
         }
      }
      //当遍历完整个 charArray 数组后，stack 就得到最后Expression
      this.expression = stack.pop();
   }

   public int run(HashMap<String, Integer> var) {
      //最后将表达式 a+b 和 var = {a=10,b=20} 传递给expression的interpreter进行解释执行
      return this.expression.interpreter(var);
   }
}

public class ClientTest {
   public static void main(String[] args) throws IOException {
      String expStr = getExpStr(); // a+b
      HashMap<String, Integer> var = getValue(expStr);// var {a=10, b=20}
      Calculator calculator = new Calculator(expStr);
      System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
   }
   // 获得表达式
   public static String getExpStr() throws IOException {
      System.out.print("请输入表达式：");
      return (new BufferedReader(new InputStreamReader(System.in))).readLine();
   }
   // 获得值映射
   public static HashMap<String, Integer> getValue(String expStr) throws IOException {
      HashMap<String, Integer> map = new HashMap<>();
      for (char ch : expStr.toCharArray()) {
         if (ch != ‘+‘ && ch != ‘-‘) {
            if (!map.containsKey(String.valueOf(ch))) {
               System.out.print("请输入" + String.valueOf(ch) + "的值：");
               String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
               map.put(String.valueOf(ch), Integer.valueOf(in));
            }
         }
      }
      return map;
   }
}

20.4 注意事项和细节

1. 当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性。
2. 使用解释器可能带来的问题：解释器模式会引起类膨胀；解释器模式采用递归调用方法，将会导致调试非常复杂，效率可能降低。

20.5 在 Spring 框架的应用

Spring 框架中 SpelExpressionParser 使用到解释器模式

• Expression 接口：表达式接口
• 有不同的实现类，如 SpelExpression、CompositeStringExpression
• 使用时，根据创建的不同的 Parser 对象，返回不同的 Expression 对象

设计模式【十三】—— 备忘录模式/解释器模式

原文：https://www.cnblogs.com/Songzw/p/13110745.html