解释器模式是指给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来接受语言中的句子。是一种按照规定的语法进行解析的模式，属于行为型模式。
解释器模式的作用其实与编译器一样，都是将一些固定的语法进行接受，构建出一个接受句子的解释器。简单理解，解释器是一个简单语法分析工具，它可以识别句子语义，分离终结符号和非终结符号，提取出需要的信息，让我们能针对不同的信息做出相应的处理。其核心思想是识别语法，构建解释。
1、抽象表达式（Expression）：负责定义一个解释方法interpret，交由具体子类进行具体解释。
2、终结符表达式（TerminalExpression）：实现文法中与终结符有关的解释操作。文法中的每一个终结符都有以恶具体终结表达式与之相对应，比如公式R=R1+R2，R1和R2就是终结符。对应的解析R1和R2的解释器就是终结符表达式。通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符（R1，R2）。
3、非终结符表达式（NonterminalExpression）：实现文法中与非终结符有关的解释操作。文法中的每条规则都对应一个非终结符表达式。非终结符表达式一般是文法中的运算符或者其他关键字，比如R=R1+R2，“+”就是非终结符，解析“+”的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的负责程度而增加，原则上每个文法规则对应一个非终结符表达式。
4、上下文环境类（Context）：包含解释器之外的全局信息。它的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，给R1赋值1，给R2赋值2，这些信息需要存放到环境中。
1、一些重复出现的问题可以用一种简单的语言来进行表达。
2、一个简单语法需要接受的场景。
抽象表达式：Expression
public interface Expression { // 对表达式进行解释 Object interpret(Context context); }上下文环境类：Context
public class Context extends HashMap{ }非终结符表达式：NonterminalExpression
public class NonterminalExpression implements Expression{ private Expression [] expressions; public NonterminalExpression(Expression... expressions) { // 每个非终结符表达式都会对其他表达式产生依赖 this.expressions = expressions; } @Override public Object interpret(Context context) { // 进行文法处理 context.put("",""); return null; } }终结符表达式：TerminalExpression
public class TerminalExpression implements Expression{ private Object value; @Override public Object interpret(Context context) { // 实现文法中与终结符有关的操作 context.put("",""); return null; } }ArithmeticInterpreter：
public interface ArithmeticInterpreter { int interpret(); }Interpreter：
public abstract class Interpreter implements ArithmeticInterpreter{ protected ArithmeticInterpreter left; protected ArithmeticInterpreter right; public Interpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) { this.left = left; this.right = right; } }NumInterpreter：
public class NumInterpreter implements ArithmeticInterpreter { private int value; public NumInterpreter(int value) { this.value = value; } @Override public int interpret() { return this.value; } }AddInterpreter：
public class AddInterpreter extends Interpreter { public AddInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) { super(left, right); } @Override public int interpret() { return this.left.interpret() + this.right.interpret(); } }SubInterpreter：
public class SubInterpreter extends Interpreter { public SubInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) { super(left, right); } @Override public int interpret() { return this.left.interpret() - this.right.interpret(); } }MultiInterpreter：
public class MultiInterpreter extends Interpreter { public MultiInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) { super(left, right); } @Override public int interpret() { return this.left.interpret() * this.right.interpret(); } }DivInterpreter：
public class DivInterpreter extends Interpreter { public DivInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) { super(left, right); } @Override public int interpret() { return this.left.interpret() / this.right.interpret(); } }OperatorUtil：
public class OperatorUtil { public static boolean isOperator(String symbol) { return ("+".equals(symbol) || "-".equals(symbol) || "*".equals(symbol)); } public static Interpreter getInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right, String symbol) { if ("+".equals(symbol)) { return new AddInterpreter(left, right); } else if ("-".equals(symbol)) { return new SubInterpreter(left, right); } else if ("*".equals(symbol)) { return new MultiInterpreter(left, right); } else if ("/".equals(symbol)) { return new DivInterpreter(left, right); } return null; } }Calculator：
public class Calculator { private Stack<ArithmeticInterpreter> stack = new Stack<ArithmeticInterpreter>(); public Calculator(String expression) { this.parse(expression); } private void parse(String expression) { String [] elements = expression.split(" "); ArithmeticInterpreter leftExpr, rightExpr; for (int i = 0; i < elements.length ; i++) { String operator = elements[i]; if (OperatorUtil.isOperator(operator)){ leftExpr = this.stack.pop(); rightExpr = new NumInterpreter(Integer.valueOf(elements[++i])); System.out.println("出栈: " + leftExpr.interpret() + " 和 " + rightExpr.interpret()); this.stack.push(OperatorUtil.getInterpreter(leftExpr, rightExpr,operator)); System.out.println("应用运算符: " + operator); } else{ NumInterpreter numInterpreter = new NumInterpreter(Integer.valueOf(elements[i])); this.stack.push(numInterpreter); System.out.println("入栈: " + numInterpreter.interpret()); } } } public int calculate() { return this.stack.pop().interpret(); } }测试类：
public class Test { public static void main(String[] args) { System.out.println("result: " + new Calculator("10 + 30").calculate()); System.out.println("result: " + new Calculator("10 + 30 - 20").calculate()); System.out.println("result: " + new Calculator("100 * 2 + 400 - 20 + 66").calculate()); } } 1、扩展性强：在解释器模式中由于语法是由很多类表示的，当语法规则更改时，只需修改相应的非终结符表达式即可，若扩展语法时，只需添加相应非终结符类即可。
2、添加了新的解释表示式的方式。
3、易于实现文法：解释器模式对应的文法应当是比较简单且易于实现的，过于复杂的语法并不适合使用解释器模式。
1、语法规则较复杂时，会引起类膨胀：解释器模式每个语法都要尝试一个非终结符表达式，当语法规则比较复杂时，就会产生大量的解释类，增加系统维护困难。
2、执行效率比较低：解释器模式采用递归调用方法，每个非终结符表达式只关心与自己有关的表达式，每个表达式需要知道最终的结果，因此完整表达式的最终结果是通过从后往前递归调用的方式获取到的。当完整表达式层次较深时，解释效率下降，且出错时调试困难，因为递归迭代层级太深。
链接: 七大设计原则的简单解释（包含合成复用原则），简单理解、快速入门，具备案例代码.
链接: 工厂模式详解附有代码案例分析（简单工厂，工厂方法，抽象工厂）.
链接: 单例模式详解及代码案例与应用场景（饿汉式单例模式、懒汉式单例模式、注册式单例模式）.
链接: 原型模式详解附有代码案例分析（浅克隆和深克隆的相关解析）.
链接: 建造者模式详解附有代码案例分析（包含建造者模式与工厂模式的区别分析）.
链接: 门面模式详解附有代码案例分析.
链接: 装饰者模式详解附有代码案例分析.
链接: 享元模式详解附有代码案例分析（包含享元模式的源码应用分析——String中的享元模式应用、Integer中的享元模式应用）.
链接: 组合模式详解附有代码案例分析（包含透明组合模式、安全组合模式的代码示例）.
链接: 桥接模式详解附有代码案例分析.
链接: 适配器模式详解附有代码案例分析（包含类适配器、对象适配器以及接口适配器的代码示例）.
链接: 委派模式详解附有代码案例分析（包含委派模式在JDK中的源码示例解析）.
链接: 模板方法模式详解附有代码案例分析（包含模板方法模式重构JDBC操作业务代码示例）.
链接: 策略模式详解附有代码案例分析（包含策略模式在源码中的应用以及代码示例）.
链接: 责任链模式详解附有代码案例分析（包含责任链模式与建造者模式的结合代码案例）.
链接: 迭代器模式详解附有代码案例分析（包含迭代器模式的源码应用分析）.
链接: 命令模式详解附有代码案例分析（包含命令模式的源码应用分析）.
链接: 状态模式详解附有代码案例分析（包含状态模式与其他相关设计模式的对比）.
链接: 备忘录模式详解附有代码案例分析.
链接: 中介者模式详解附有代码案例分析.
链接: 解释器模式详解附有代码案例分析.
链接: 观察者模式详解附有代码案例分析（包含观察者模式使用JDK方式实现）.
链接: 访问者模式详解附有代码案例分析.
