1、四则运算问题
通过解释器模式来实现四则运算问题，如计算 a+b-c 的值，具体要求
1）先输入表达式的形式，比如 a+b+c-d+e，要求表达式的字母不能重复
2）再分别输入 a、b、c、d、e 的值
3）最后求出结果，如下
请输入表达式： a+b+c-d+e
请输入 a 的值： 10
请输入 b 的值： 11
请输入 c 的值： 1
请输入 d 的值： 2
请输入 e 的值： 3
运算结果：a+b+c-d+e = 23
2、传统方案解决四则运算问题分析
1）编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果
2）问题分析：如果加入新的运算符，比如 * / 等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰
3）解决方案：可以考虑使用解释器模式，即：表达式 -> 解释器（可以有多种） -> 结果
3、解释器模式
3.1 基本介绍
1）在编译原理中，一个算术表达式通过词法分析起形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
2）解释器模式（Interpreter Pattern）：是指给定一个语言（表达式），定义他的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）
3）应用场景
- 应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
- 一些重复出现的问题可以用一种简单的语言来表达
- 一个简单语法需要解释的场景
4）这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等
3.2 原理类图
说明（角色及职责）：
1）Context：是环境角色，含有解释器之外的全局信息
2）AbstractExpression：抽象表达式，声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享
3）TerminalExpression：为终结符表达式，实现与文法中的终结符相关的解释操作
4）NonTerminalExpression：为非终结符表达式，为文法中的非终结符实现解释操作
5）说明：输入 Context、TerminalExpression 信息通过 Client 输入即可
3.3 应用实例
1）要求
通过解释器模式来实现四则运算，如计算 a+b-c 的值
2）思路分析和图解（类图）
3）代码实现
Expression 表达式抽象类
package com.wenze.design.interpreter;
import java.util.HashMap;
/**
* 表达式抽象类
*
* @author 汶泽
* @version 1.0
* @date 2023-11-09 17:10:58
* @since 1.0
*/
public abstract class Expression {
public abstract int interpreter(HashMap<String, Integer> var);
}
VarExpression 变量解释器
package com.wenze.design.interpreter;
import lombok.AllArgsConstructor;
import java.util.HashMap;
/**
* 变量的解释器
*
* @author 汶泽
* @version 1.0
* @date 2023-11-09 17:19:51
* @since 1.0
*/
@AllArgsConstructor
public class VarExpression extends Expression {
private String key;
@Override
public int interpreter(final HashMap<String, Integer> var) {
return var.get(this.key);
}
}
SymbolExpression 运算符号解释器
package com.wenze.design.interpreter;
import lombok.AllArgsConstructor;
import java.util.HashMap;
/**
* 运算符号解释器
*
* @author 汶泽
* @version 1.0
* @date 2023-11-09 17:11:16
* @since 1.0
*/
@AllArgsConstructor
public class SymbolExpression extends Expression {
protected Expression left;
protected Expression right;
@Override
public int interpreter(HashMap<String, Integer> var) {
return 0;
}
}
AddExpression 加法运算解释器
package com.wenze.design.interpreter;
import java.util.HashMap;
/**
* 加法运算表达式
*
* @author 汶泽
* @version 1.0
* @date 2023-11-09 17:11:49
* @since 1.0
*/
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);
}
}
SubExpression 减法运算表达式
package com.wenze.design.interpreter;
import java.util.HashMap;
/**
* 减法运算表达式
*
* @author 汶泽
* @version 1.0
* @date 2023-11-09 17:16:53
* @since 1.0
*/
public class SubExpression extends SymbolExpression {
public SubExpression(final Expression left, final Expression right) {
super(left, right);
}
@Override
public int interpreter(final HashMap<String, Integer> var) {
return super.left.interpreter(var) - super.right.interpreter(var);
}
}
Calculator 计算器
package com.wenze.design.interpreter;
import java.util.HashMap;
import java.util.Stack;
/**
* 计算器
*
* @author 汶泽
* @version 1.0
* @date 2023-11-09 17:41:21
* @since 1.0
*/
public class Calculator {
private Expression expression;
public Calculator(String expStr) {
final Stack<Expression> stack = new Stack<>();
final 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);
}
}
Client 客户端
package com.wenze.design.interpreter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
/**
* 客户端
*
* @author 汶泽
* @version 1.0
* @date 2023-11-09 17:49:05
* @since 1.0
*/
public class Client {
public static void main(String[] args) throws IOException {
String expStr = getExpStr();
HashMap<String, Integer> var = getValue(expStr);
final Calculator calculator = new Calculator(expStr);
System.out.println("运算结果：" + expStr + " = " + calculator.run(var));
}
private static HashMap<String, Integer> getValue(final String expStr) throws IOException {
HashMap<String, Integer> var = new HashMap<>();
for (final char ch : expStr.toCharArray()) {
if (ch != '+' && ch != '-') {
if (!var.containsKey(String.valueOf(ch))) {
System.out.print("请输入 " + String.valueOf(ch) + " 的值：");
String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
var.put(String.valueOf(ch), Integer.parseInt(in));
}
}
}
return var;
}
public static String getExpStr() throws IOException {
System.out.print("请输入表达式：");
return (new BufferedReader(new InputStreamReader(System.in))).readLine();
}
}
4、解释器模式在 Spring 框架应用的源码剖析
1）Spring 框架中 SpelExpressionParser 就用到解释器模式
2）代码分析 + Debug 源码
3）说明
- Expression 接口，表达式接口
- 下面有不同的实现类，比如
SpelExpression，或者CompositeStringExpression。 - 使用时候，根据你创建的不同的 Parser 对象，返回不同的 Expression 对象
public Expression parseExpression(String expressionString,
ParserContext context) throws ParseException {
if (context != null && context.isTemplate()) {
return parseTemplate(expressionString, context);
}
else {
return doParseExpression(expressionString, context);
}
}
- 使用的当 Expression 对象，调用
getValue解释执行表达式，最后得到结果
5、解释器模式的注意事项和细节
1）当有一个语言需要解释执行，可将改语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性
2）应用场景：编译器、运算表达式计算、正则表达式、机器人等
3）使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复杂、效率可能降低
