解释器模式是一种行为模式，实际开发中用的很少，提供了一种解释语言的语法或表达式的方式。
定义了一个表达式接口，通过接口解释一个特定的上下文。类似于json解析器按一定的语法解析json的。
博客地址
定义
给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
什么是文法？文法就是语言的规则，语法。每一个语法都对应一个解释器对象，解释器根据语法来解释相应的句子。
举个例子，那汉语中的主谓宾结构来说，我们经常是自己是什么是这样说的，我是程序员，``我是设计师...。那么，就可以把我是[职位]定义为一条文法。解释器一看见这样的文法，就能解析出来你的职业是[职业]`。
使用场景
- 当一个语言需要解释执行，并且该语言中的句子可以表示为一个抽象的语法树时。
- 某些重复出现的问题，可以用一种简单的语言来表示的时候，可以将这个问题转化为一种语法规则下的语句。
UML
- AbstractExpression:抽象的解析方法。声明一个解析方法，具体实现在具体的子类中完成
- TernimalExprission:实现对文法中与终结符有关的解释操作。
- NonterminalExpression:实现对文法中的非终结符有关的解释操作。
- Context：包含解释器之外的全部信息。
- Client: 解析表达式，构建抽象语法书，执行具体的解释操作等。
简单实现
以数字计算为例，``a+b+c,如果使用解释器模式对表达式进行解释，那么a,b,c可以看做是终结负号，+`看做是非终结负号。
抽象的解释器，定义每个解释器都有个方法提取结果值
public abstract class ArithmeticExpression {
public abstract int interpret();
}
数字解释器，仅仅解释数字
public class NumExpression extends ArithmeticExpression {
private int num;
public NumExpression(int num) {
this.num = num;
}
@Override
public int interpret() {
return num;
}
}
抽象的运算符解释器，要求传入两个参数进行计算
public abstract class OperatorExpression extends ArithmeticExpression {
protected ArithmeticExpression exp1,exp2;
public OperatorExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
this.exp1 = exp1;
this.exp2 = exp2;
}
}
一个具体的加法运算符,解析出两个参数的和
public class AddExpression extends OperatorExpression {
public AddExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
super(exp1, exp2);
}
@Override
public int interpret() {
return exp1.interpret()+exp2.interpret();
}
}
一个计算类，处理与解析相关的业务
public class Calculator {
private Stack<ArithmeticExpression> mExp = new Stack<>();
//使用的时候在构造方法里传入要计算的字符串。
public Calculator(String expression) {
//准备两个解释器
ArithmeticExpression exp1, exp2;
//将字符串按空格分割
String[] elements = expression.split(" ");
for (int i = 0; i < elements.length; i++) {
switch (elements[i].charAt(0)) {
case '+':
//如果是’+‘，说明是个运算符，将上一个数和下一个数相加，也就是当前下标i的i-1和i+1相加。
//去除栈中前一次压如的数。也就是这个加号之前的计算结果。
exp1 = mExp.pop();
//取出这个加号后面的数，解析成数字，
exp2 = new NumExpression(Integer.valueOf(elements[++i]));
//将这两个数进行计算，并将结果压入栈中。
mExp.push(new AddExpression(exp1,exp2));
break;
default:
//如果是数字，就解析为数字，加入栈中。
mExp.push(new NumExpression(Integer.valueOf(elements[i])));
break;
}
}
}
public int calculate(){
return mExp.pop().interpret();
}
}
客户端调用
public class Client {
public static void main(String[] args) {
Calculator calculator = new Calculator("1 + 2 + 3");
System.out.println(calculator.calculate());
}
}
可以看到输出结果是
6
如果需要加上减号运算符呢？就子啊实现一个减号的解析器：
public class Subtraction extends OperatorExpression {
public Subtraction(ArithmeticExpression exp1, ArithmeticExpression exp2) {
super(exp1, exp2);
}
@Override
public int interpret() {
return exp1.interpret()-exp2.interpret();
}
}
然后在计算的类里加一种判断：
case '-':
exp1 = mExp.pop();
exp2 = new NumExpression(Integer.valueOf(elements[++i]));
mExp.push(new SubtractionExpression(exp1,exp2));
break;
客户端调用
public class Client {
public static void main(String[] args) {
Calculator calculator = new Calculator("1 + 2 + 3 - 1");
System.out.println(calculator.calculate());
}
}
可以看到输出结果变成了
5
上面只是一个简单的算术运算的解析。根据这个模式，可以增加很多运算法则，只要创建响应的解释器就可以。
由于解释器和文法是一一对应的，所以一个解释器只负责解析一种文法。我们可以为一种文法创建多个解释器，但不能用一个解释器解析多重文法。
解释器值负责解析单个的文法，所以解析树的建立就有距离的使用者去根据实际情况构建了。
总结
优点
- 拓展性很灵活，需要增加新的解释器的时候，直接实现一个新的就行了，然后在实际运用中灵活构建语法树来运用。
缺点
- 每一个文法都至少对应一个解释器，会产生大量的类，维护困难。
- 对于复杂的文法，要构建语法书会非常繁琐，甚至需要构建多颗语法树。
