设计模式（23）行为型模式 - 解释器模式

前言

温故而知新

先复习前面学习到的行为型设计模式：

• 模板方法模式：定义一个操作流程的骨架，特定的步骤延迟到子类实现，即可重定义模板（请客流程：点单-》吃东西-》买单，吃什么具体由子类实现，即可定义不同的请客流程）
• 命令模式：将命令封装成对象，命令对象聚合执行者，命令请求者调用命令对象即可完成命令，实现命令请求者和命令执行者的解耦合（遥控器上的一个个按钮是命令对象，点击按钮即可完成开关灯）
• 访问者模式：将施加于对象结构的元素上的操作隔离，封装成访问者，对象结构提供了访问者访问的接口，即修改访问操作不会改变对象结构（购物车是一个对象结构，存放了很多商品元素对象，顾客可以访问购物车中商品的质量，收银员可以访问商品的价格）
• 迭代器模式：将聚合对象的存储功能和遍历功能分隔，遍历功能封装成迭代器，聚合对象以工厂方法创建相对应的迭代器（Linux目录迭代器访问目录的层级）
• 观察者模式：定义对象间一对多的依赖关系，当对象的状态改变时，自动通知所有依赖的对象并更新依赖对象的数据（气象局天气数据改变，所有APP的天气信息也会改变）
• 中介者模式：针对对象间网状结构关系的复杂，定义一个中介对象，封装对象间的互相交互，使得对象间没有显示的交互关系，通过中介对象可以间接与其他对象通信（QQ聊天，通过服务器可以跟任何人聊天，而不需要知道对方的IP地址）
• 备忘录模式：在对象外保存对象的内部状态，提供给对象恢复功能（游戏存档读档）

接下来，进行解释器模式的学习
需要一定的编译原理知识

---

现实中的问题

现在很火热的机器人，为什么它可以听懂我们的一些话？

机器人遇到有些问题多次重复出现，而且有一定的相似性和规律性。将它们归纳成一种简单的机器人可以解析的语言

我们问机器人“你是谁？”
机器人就可以分析我们的语句，“你”、“是”、“谁”，解析知道我们的问题，回答结果

这是编译原理中的思想：
编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。
这里的词法分析器和语法分析器都可以看做是解释器

这样一个解析器：输入的是一个句子“1+2+3-4+1”，一个字符串
解释器把它解释成一个算数表达式：“1”+“2”+“3”-“4”+“1”
然后计算出结果，具体的实现看后面的案例

---

解释器模式

什么是解释器模式？

解释器模式(Interpreter Pattern) ：给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文

关于文法、句子、语法树、语言的定义，是编译原理的知识，可以自行查找
（没有点编译原理的常识，挺难理解解释器模式）

为什么要解释器模式？

解释器模式描述了如何构成一个简单的语言解释器

如果在系统中某一特定类型的问题发生的频率很高，此时可以考虑将这些问题的实例表述为一个语言中的句子，因此可以构建一个解释器，该解释器通过解释这些句子来解决这些问题

上面的加减法解释器就是识别加号，就把加号左右两边的字符的值加起来
识别减号，就把减号的左边的值减去右边的值

关键在与如何去识别加号减号，后面通过内置字符比较识别，这只是一种最简单的识别

解释器模式结构

模式角色：

• 抽象表达式（AbstractExpression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法interpret()。
• 终结符表达式（TerminalExpression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
• 非终结符表达式（NonterminalExpression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
• 环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。
• 客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法

---

模式实现

简单实现上面的加减算法解释器

抽象表达式角色：定义了一个抽象解释方法
解释方法传入HashMap集合，例如 { a=1,b=2}
传值格式是在客户端传值时处理传入值的规范

package com.company.Behavioral.Explanation;

import java.util.HashMap;


public abstract class Expression {

	public abstract int interpreter(HashMap<String, Integer> var);
}

终结符表达式角色：内部定义了左、右表达式类
终结符表达式角色是各种符号：加号减号，左右必定有表达式
这里没有去设置错误信息监测

package com.company.Behavioral.Explanation;

import java.util.HashMap;


public class SymbolExpression extends Expression {

	protected Expression left;
	protected Expression right;

	public SymbolExpression(Expression left, Expression right) {
		this.left = left;
		this.right = right;
	}

	@Override
	public int interpreter(HashMap<String, Integer> var) {
		return 0;
	}
}

非终结符表达式角色：它表示运算表达式具体的数值

package com.company.Behavioral.Explanation;

import java.util.HashMap;


public class VarExpression extends Expression {

	private String key; 

	public VarExpression(String key) {
		this.key = key;
	}

	@Override
	public int interpreter(HashMap<String, Integer> var) {
		return var.get(this.key);
	}
}

具体终结符表达式角色：加号+
获得左右表达式的值进行加法

package com.company.Behavioral.Explanation;

import java.util.HashMap;


public class AddExpression extends SymbolExpression  {

	public AddExpression(Expression left, Expression right) {
		super(left, right);
	}

	@Override
	public int interpreter(HashMap<String, Integer> var) {
		return super.left.interpreter(var) + super.right.interpreter(var);
	}
}

具体终结符表达式角色：减号+
获得左右表达式的值进行减法

package com.company.Behavioral.Explanation;

import java.util.HashMap;

public class SubExpression extends SymbolExpression {

	public SubExpression(Expression left, Expression right) {
		super(left, right);
	}

	@Override
	public int interpreter(HashMap<String, Integer> var) {
		return super.left.interpreter(var) - super.right.interpreter(var);
	}
}

环境角色：也就是我们的计算机对象
较为复杂，就是编译原理中语法分析的过程，最终会生成唯一一个表达式对象

package com.company.Behavioral.Explanation;

import java.util.HashMap;
import java.util.Stack;

public class Calculator {


	private Expression expression;


	public Calculator(String expStr) {

		Stack<Expression> stack = new Stack<>();
		char[] charArray = expStr.toCharArray();

		Expression left = null;
		Expression right = null;
		for (int i = 0; i < charArray.length; i++) {
			switch (charArray[i]) {
			case '+': //读取到的是+
				left = stack.pop();//弹栈，得到刚才压入栈中的值，设置为左表达式
				right = new VarExpression(String.valueOf(charArray[++i]));//当前值右边一位为右表示式
				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: //非终结符就直接放入栈中
				stack.push(new VarExpression(String.valueOf(charArray[i])));
				break;
			}
		}
		//最终会得到一个表达式对象
		this.expression = stack.pop();
	}
	//运行计算，即调用表达式对象的解释方法
	public int run(HashMap<String, Integer> var) {
		return this.expression.interpreter(var);
	}
}

客户端：需要把输入的数据放置在HashMap中

package com.company.Behavioral.Explanation;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

public class ClientTest {

	public static void main(String[] args) throws IOException {

		String expStr = getExpStr(); 
		HashMap<String, Integer> var = getValue(expStr);
		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;
	}
}

---

模式优缺点

优点

• 易于改变和扩展文法
• 易于实现文法
• 增加了新的解释表达式的方式

因为都是继承抽象表达式类Expression，添加新的终结符表达式角色仅需增加一个新角色，并在计算机对象中稍加修改

缺点

• 对于复杂文法难以维护：仅上面的加减法就如此复杂，如果把科学计数器的各种符号加上，可想有多复杂
• 执行效率较低：这个是没办法的，编译原理就是要分析语法树
• 应用场景很有限：想想，用到编译器、解释器的地方真的不多，普通的软件基本不需要

---

适用环境

• 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
• 一些重复出现的问题可以用一种简单的语言来进行表达
• 文法较为简单
• 效率不是关键问题

现实中使用

• 解释器模式在使用面向对象语言实现的编译器中得到了广泛的应用，如Smalltalk语言的编译器
• 目前有一些基于Java抽象语法树的源代码处理工具，如在Eclipse中就提供了Eclipse AST，它是Eclipse JDT的一个重要组成部分，用来表示Java语言的语法结构，用户可以通过扩展其功能，创建自己的文法规则
• 可以使用解释器模式，通过C++、Java、C#等面向对象语言开发简单的编译器，如数学表达式解析器、正则表达式解析器等，用于增强这些语言的功能，使之增加一些新的文法规则，用于解释一些特定类型的语句
• 第三方解析工具包： 数学表达式解析器(Math Expression Parser, MEP)，如Expression4J、Jep、JbcParser、Symja、Math Expression String Parser(MESP)等来取代解释器模式，它们可以方便地解释一些较为复杂的文法，功能强大，且使用简单，效率较好

---

总结

• 解释器模式很复杂，使用频率也少，涉及到了编译原理知识
• 解释器模式给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子
• 解释器模式有5个角色：抽象表达式角色、非终结符表达式角色、终结符表达式角色、环境角色、客户类
• 抽象表达式角色定义解释方法；非终结符表达式角色将非终结符的数值取出；终结符表达式角色实现与终结符相关的文法操作（+、-等）；环境角色传递解释器需要的数据和功能；客户类传递数据给环境角色
• 解释器模式的优点：易于改变和扩展文法，易于实现文法并增加新的解释表达式的方式；缺点：对复杂文法难以维护，运行效率低，应用场景有限
• 解释器模式适用场景：可以将一个需要解释执行的语言中的句子表示为一个抽象语法树；一些重复出现的问题可以用一种简单的语言来进行表达；文法较为简单且效率不是关键问题
• 实际使用中，可以调用第三方库来完成对语法的解释