解释器模式
解释器模式（Interpreter Pattern）是一种按照规定语法进行解析的方案，在现在项目中使 用较少，其定义如下：Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language。
优点
解释器是一个简单语法分析工具，它最显著的优点就是扩展性，修改语法规则只要修改 相应的非终结符表达式就可以了，若扩展语法，则只要增加非终结符类就可以了。
缺点
- 解释器模式会引起类膨胀。
- 解释器模式采用递归调用方法。
- 效率问题：解释器模式由于使用了大量的循环和递归，效率是一个不容忽视的问题，特别是一用于 解析复杂、冗长的语法时，效率是难以忍受的。
使用场景
- 重复发生的问题可以使用解释器模式
- 一个简单语法需要解释的场景
例子：模拟计算表达式
- 抽象表达式
/**
* 抽象表达式
*
* @author admin
*/
public abstract class Expression {
/**
* 解析公式和数值，其中var中的key值是公式中的参数，value值是具体的数字
*
* @param var 参数
* @return 返回值
*/
public abstract int interpreter(HashMap<String, Integer> var);
}
- 变量解析器
import java.util.HashMap;
/**
* 变量解析器
*
* @author admin
*/
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(key);
}
}
- 抽象运算符号解析器
/**
* 抽象运算符号解析器
*
* @author admin
*/
public abstract class SymbolExpression extends Expression {
protected Expression left;
protected Expression right;
/**
* 所有的解析公式都应只关心自己左右两个表达式的结果
*
* @param left 左侧表达式
* @param right 右侧表达式
*/
public SymbolExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
}
- 加法解析器
import java.util.HashMap;
/**
* 加法解析器
*
* @author admin
*/
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);
}
}
- 减法解析器
import java.util.HashMap;
/**
* 减法解析器
*
* @author admin
*/
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);
}
}
- 解析器封装类
import java.util.HashMap;
import java.util.Stack;
/**
* 解析器封装类
*
* @author admin
*/
public class Calculator {
//定义表达式
private Expression expression;
//构造函数传参，并解析
public Calculator(String expStr) {
//定义一个栈，安排运算的先后顺序
Stack<Expression> stack = new Stack<>();
//表达式拆分为字符数组
char[] charArray = expStr.toCharArray();
//运算
Expression left;
Expression right;
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])));
}
}
//把运算结果抛出来
this.expression = stack.pop();
}
//开始运算
public int run(HashMap<String, Integer> var) {
return this.expression.interpreter(var);
}
}
- 客户端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class Client {
//运行四则运算
public static void main(String[] args) throws IOException {
String expStr = getExpStr();
//赋值
HashMap<String, Integer> var = getValue(expStr);
Calculator cal = new Calculator(expStr);
System.out.println("运算结果为：" + expStr + "=" + cal.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 exprStr) throws IOException {
HashMap<String, Integer> map = new HashMap<>();
//解析有几个参数要传递
for (char ch : exprStr.toCharArray()) {
if (ch != '+' && ch != '-') {
//解决重复参数的问题
if (!map.containsKey(String.valueOf(ch))) {
String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
map.put(String.valueOf(ch), Integer.valueOf(in));
}
}
}
return map;
}
}