一、介绍：

1、定义：解释器(Interpreter)模式是一种对象的行为模式。给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

2、组成结构：

（1）AbstractExpression(抽象表达式)：约定解释器的解释操作，主要是一个interpret()方法。这个接口作为抽象语法树中所有节点（即终结符表达式和非终结符表达式）所共享

public abstract class AbstractExpression {public abstract void interpret(Context context);
}

（2） TerminalExpression（终结符表达式）：用来实现文法中和终结符相关的解释操作，不再包含其它的解释器，如果用组合模式来构建抽象语法树的话，就相当于组合模式中的叶子对象，可以有多种终结符解释器。

public class TerminalExpression extends AbstractExpression{@Overridepublic void interpret(Context context) {System.out.println("终结符解释器");}
}

（3）NonterminalExpression（非终结表达式）：用来实现文法中和非终结符相关的解释操作，通常一个解释器对应一个语法规则，可以包含其它的解释器，如果用组合模式来构建抽象语法树的话，就相当于组合模式中的组合对象，可以有多种非终结符解释器。公式R=R1+R2中，R1、R2为终结符表达式，+为非终结表达式（其后需要跟随一个终结符表达式）。

public class NonterminalExpression extends AbstractExpression{@Overridepublic void interpret(Context context) {System.out.println("非终结符解释器");}
}

（4） Context类（包含解释器之外的一些全局信息）：也称“上下文”，常用HashMap来代替，通常包含解释器之外的一些全局信息（解释器需要的数据，或是公共的功能）。

public class Context {private String input;private String output;//Get、Set方法省略
}

客户端，构建文法表示的抽象语法树（Abstract Syntax Tree)，该抽象语法树由终结符表达式和非终结符表达式的实例装配而成），并调用解释操作interpret()方法。 

Context context = new Context();List<AbstractExpression> list = new ArrayList<AbstractExpression>();list.add(new TerminalExpression());list.add(new NonterminalExpression());list.add(new TerminalExpression());list.add(new NonterminalExpression());for (AbstractExpression abstractExpression : list) {abstractExpression.interpret(context);}

3、适用场景：解释器模式似乎使用面不是很广，它描述了一个语言解释器是如何构成的，在实际应用中，我们可能很少去构造一个语言的文法。建议在以下情况中选用解释器模式： 当有一个语言需要解释执行，并且可以将语言中的句子表示为一个抽象语法树的时候，可以考虑使用解释器模式。  

二、demo:

1、加减法计算器：

//抽象表达式
public interface AbstractExpression {int interprete(HashMap<String, Integer> var);
}//终结符表达式
public class VarExpression  implements AbstractExpression {private String key;public VarExpression(String key) {this.key = key;}public int interprete(HashMap<String, Integer> var) {return (Integer) var.get(this.key);}
}//加法符号  非终结表达式
public class AddExpression implements AbstractExpression{private AbstractExpression left;private AbstractExpression right;public AddExpression(AbstractExpression left, AbstractExpression right) {this.left = left;this.right = right;}// 把左右两个表达式运算的结果加起来public int interprete(HashMap<String, Integer> var) {return this.left.interprete(var) + this.right.interprete(var);}
}//减法符号  非终结表达式
public class SubExpression implements AbstractExpression{private AbstractExpression left;private AbstractExpression right;public SubExpression(AbstractExpression left, AbstractExpression right) {this.left = left;this.right = right;}// 把左右两个表达式运算的结果加起来public int interprete(HashMap<String, Integer> var) {return this.left.interprete(var) - this.right.interprete(var);}
}

//封装计算器类
public class Calculator {private AbstractExpression expression;public Calculator(String expStr) {// 定义一个堆栈，安排运算的先后顺序Stack<AbstractExpression> stack = new Stack<AbstractExpression>();// 表达式拆分为字符数组char[] charArray = expStr.toCharArray();// 运算AbstractExpression left = null;AbstractExpression 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])));}}// 把运算结果抛出来this.expression = stack.pop();}// 计算结果public int calculate(HashMap<String, Integer> var) {return this.expression.interprete(var);}
}//客户端
public static void main(String args[]){// 构造运算元素的值列表HashMap<String, Integer> ctx = new HashMap<String, Integer>();ctx.put("a", 10);ctx.put("b", 20);ctx.put("c", 30);ctx.put("d", 40);ctx.put("e", 50);ctx.put("f", 60);Calculator calc = new Calculator("a+b-c");int result = calc.calculate(ctx);System.out.println("Result of a+b-c: " + result);calc = new Calculator("d-a-b+c");result = calc.calculate(ctx);System.out.println("Result of d-a-b+c: " + result);}输出：
Result of a+b-c: 0
Result of d-a-b+c: 40