23种设计模式之解释器模式

解释器模式（Interpreter Paattern）是一种比较少见的行为型模式，其提供了一种解释语言的语法或表达式，该模式定义了一个表达式接口，通过该接口解释一个特定的上下文。在这么多设计模式中，解释器模式在实际运用上相对来说要少很多，因为我们很少会自己去构造一个语言的文法。

定义
给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。ps：这里看不懂也没关系，接着往下看，定义没那么重要，理解万岁。

解释器模式的使用场景
a.如果某个简单的语言需要解释执行而且可以将该语言中的语句表示为一个抽象语法树时可以考虑使用解释器模式
b.在某些特定的领域出现不断重复的问题时，可以将该领域的问题转化为一种语法规则下的语句，然后构建解释器来解释该语句。

解释器模式的UML类图

角色介绍：
AbstractExpression: 抽象表达式。声明一个抽象的解释操作，该接口为抽象语法树中所有的节点共享。
TerminalExpression: 终结符表达式。实现与文法中的终结符相关的解释操作。实现抽象表达式中所要求的方法。文法中每一个终结符都有一个具体的终结表达式与之相对应。
NonterminalExpression: 非终结符表达式。为文法中的非终结符相关的解释操作。
Context: 环境类。包含解释器之外的一些全局信息。
Client: 客户类。

PHP的简单实现

//抽象的算术运算解释器，为所有解释器共性的提取
public abstract class ArithmeticExpression {
    /**
     * 抽象的解析方法
     * 具体的解析逻辑由具体的子类实现
     * @return
     */
    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 AdditionExpression extends OperatorExpression {
    public AdditionExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }

    @Override
    public int interpret() {
        return exp1.interpret() + exp2.interpret();
    }
}

//处理与解释相关的一些业务
public class Calculator {
    //声明一个Stract栈存储并操作所有相关的解释器
    private Stack<ArithmeticExpression> mExpStrack = new Stack<>();

    public Calculator(String expresion) {
        //声明两个ArithmeticExpression类型的临时变量，存储运算符左右
        ArithmeticExpression exp1, exp2;

        //根据空格分隔表达式字符串
        String[] elements = expresion.split(" ");
        for(int i = 0; i < elements.length; i++) {
          switch (elements[i].charAt(0)){
              case '+'://如果是加号
                  //则将栈中的解释器弹出作为运算符号左边的数字解释器
                  exp1 = mExpStrack.pop();

                  //同时将运算符号数组下标下一个元素构造为一个数字解释器
                  exp2 = new NumExpression(Integer.valueOf(elements[++i]));

                  //通过上面两个数字解释器构造加法运算解释器
                  mExpStrack.push(new AdditionExpression(exp1,exp2));
                  break;

              default: //如果是数字
                  /**
                   * 如果不是运算符则为数字
                   * 若是数字，直接构造数字解释器并压入栈
                   */
                  mExpStrack.push(new NumExpression(Integer.valueOf(elements[i])));
                  break;
          }
        }
    }

    /**
     * 计算结果
     * @return
     */
    public int calculate(){
        return mExpStrack.pop().interpret();
    }
}

//客户端
public class Client {
    public static void main(String[] args){
        Calculator calculator = new Calculator("153 + 1223 + 66 + 99");
        System.out.println(calculator.calculate());
    }
}

这个是加法的一个解释器，如果想添加一个减法，定义一个减法解释器即可。

//减法运算的抽象解释器
public class SubtractionExpression extends OperatorExpression {
    public SubtractionExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }

    @Override
    public int interpret() {
        return exp1.interpret() - exp2.interpret();
    }
}

//客户端直接写就OK
public class Client {
    public static void main(String[] args){
        Calculator calculator = new Calculator("153 + 1223 + 66 + 99 - 66");
        System.out.println(calculator.calculate());
    }
}

结果大家自己尝试，如果想添加乘法和除法，也可以自己再定义相应的解释器，然后在Calculator 类中多写两个case。

优点

1、 可扩展性比较好，灵活。
2、 增加了新的解释表达式的方式。
3、 易于实现文法。

缺点

1、 执行效率比较低，可利用场景比较少。
2、 对于复杂的文法比较难维护。

总结
1、在解释器模式中由于语法是由很多类表示的，所以可扩展性强。
2、虽然解释器的可扩展性强，但是如果语法规则的数目太大的时候，该模式可能就会变得异常复杂。所以解释器模式适用于文法较为简单的。
3、解释器模式可以处理脚本语言和编程语言。常用于解决某一特定类型的问题频繁发生情况。