什么是解释器模式
定义：给定一个语言，定义一个文法的一种表示， 并定义一个解释器， 这个解释器使用该表示来解释语言中的句子。
为了解释一种语言，而为语言创建的解释器。
解释器模式所涉及的角色如下所示：
1、抽象表达式(Expression)角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。
2、终结符表达式(Terminal Expression)角色：实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
3、非终结符表达式(Nonterminal Expression)角色：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+"就是非终结符，解析“+”的解释器就是一个非终结符表达式。
4、环境(Context)角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。
解释器模式的使用场景
1、当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树，可以使用解释器模式。而当存在以下情况时该模式效果最好
2、该文法的类层次结构变得庞大而无法管理。此时语法分析程序生成器这样的工具是最好的选择。他们无需构建抽象语法树即可解释表达式，这样可以节省空间而且还可能节省时间。
3、效率不是一个关键问题，最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将他们装换成另一种形式，例如，正则表达式通常被装换成状态机，即使在这种情况下，转换器仍可用解释器模式实现，该模式仍是有用的
解释器模式的优缺点
优点：
1、可以很容易地改变和扩展方法， 因为该模式使用类来表示方法规则， 你可以使用继承来改变或扩展该方法。
2、也比较容易实现方法， 因为定义抽象语法树总各个节点的类的实现大体类似， 这些类都易于直接编写。
3、解释器模式就是将一句话，转变为实际的命令程序执行而已。 而不用解释器模式本身也可以分析， 但通过继承抽象表达式的方式， 由于依赖转置原则， 使得文法的扩展和维护都带来的方便。
缺点：
解释器模式为方法中的每一条规则至少定义了一个类， 因此包含许多规则的方法可能难以管理和维护。 因此当方法非常复杂时， 使用其他的技术如 语法分析程序 或 编译器生成器来处理。
解释器模式的实现
抽象表达式(Expression)角色
public interface Interpreter {
int interpret();
}
终结符表达式(Terminal Expression)角色
public class AddInterpreter implements Interpreter {
private Interpreter firstExpression,secondExpression;
public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpret() {
return this.firstExpression.interpret()+this.secondExpression.interpret();
}
@Override
public String toString() {
return "+";
}
}
public class MultiInterpreter implements Interpreter {
private Interpreter firstExpression,secondExpression;
public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpret() {
return this.firstExpression.interpret()*this.secondExpression.interpret();
}
@Override
public String toString() {
return "*";
}
}
public class NumberInterpreter implements Interpreter {
private int number;
public NumberInterpreter(int number) {
this.number = number;
}
public NumberInterpreter(String number) {
this.number = Integer.parseInt(number);
}
@Override
public int interpret() {
return this.number;
}
}
环境(Context)角色
public class GeelyExpressionParser {
private Stack<Interpreter> stack = new Stack<>();
public int parse(String str){
String[] strItemArray = str.split(" ");
for (String symbol : strItemArray) {
if(!OperatorUtil.isOperator(symbol)){
Interpreter numberInterpreter = new NumberInterpreter(symbol);
stack.push(numberInterpreter);
System.out.println(String.format("入栈: %d",numberInterpreter.interpret()));
}else {
//是运算符号，可以计算
Interpreter firstExpression = stack.pop();
Interpreter secondExpression = stack.pop();
System.out.println(String.format("出栈: %d 和 %d",firstExpression.interpret(),secondExpression.interpret()));
Interpreter operator = OperatorUtil.getExpressionObject(firstExpression,secondExpression,symbol);
System.out.println(String.format("应用运算符：%s ",operator));
int result = operator.interpret();
NumberInterpreter resultExpression = new NumberInterpreter(result);
stack.push(resultExpression);
System.out.println(String.format("阶段结果入栈：%d",resultExpression.interpret()));
}
}
int result = stack.pop().interpret();
return result;
}
}
其他封装的工具类
public class OperatorUtil {
public static boolean isOperator(String symbol){
return ("+".equals(symbol) || "*".equals(symbol));
}
public static Interpreter getExpressionObject(Interpreter firstExpression,Interpreter secondExpression,String symbol){
if("+".equals(symbol)){
return new AddInterpreter(firstExpression,secondExpression);
}else if("*".equals(symbol)){
return new MultiInterpreter(firstExpression,secondExpression);
}
return null;
}
}
客户端代码
public class Test {
public static void main(String[] args) {
String geelyInputStr = "6 100 11 + *";
GeelyExpressionParser expressionParser = new GeelyExpressionParser();
int result = expressionParser.parse(geelyInputStr);
System.out.println("解释器计算结果："+result);
}
}
