《Android源码设计模式》之解释器模式

解释器模式介绍

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

解释器模式的定义

给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
　　文法：文章的书写法规，一般用来指以文字、词语、短句、句子的编排而组成的完整语句和文章的合理性组织。例如：“我是程序员”、“我是设计师”等等都是一条文法。
　　解释器模式的定义：给定一个语言（如由abcdef六个字符组成的字符串集合），定义它的文法的一种表示（如S::=abA*ef和A::=cd），并定义一个解释器，该解释器使用该表示来解释语言中的句子。

解释器模式的使用场景

解释器模式的使用场景其实相当广泛，总的概括下来大致有如下两种：
　　（1）如果某个简单的语言需要解释执行而且可以将该语言中的语句表示为一个抽象语法树时可以考虑使用解释器模式。
　　（2）在某些特定的领域出现不断重复的问题时，可以将该领域的问题转化为一种语法规则下的语句，然后构建解释器来解释该语句。

解释器模式的UML类图

根据类图可以得出如下一个解释器模式的通用代码。

抽象表达式

package com.guifa.interpreterpatterndemo;

import android.content.Context;

public abstract class AbstractExpression {
    /**
     * 抽象的解释方法
     *
     * @param context 上下文环境对象
     */
    public abstract void interpret(Context context);
}

终结符表达式

package com.guifa.interpreterpatterndemo;

import android.content.Context;

public class TerminalExpression extends AbstractExpression {
    @Override
    public void interpret(Context context) {
        // 实现文法中与终结符有关的解释操作
    }
}

非终结符表达式

package com.guifa.interpreterpatterndemo;

import android.content.Context;

public class NonterminalExpression extends AbstractExpression {
    @Override
    public void interpret(Context context) {
        // 实现文法中与非终结符有关的解释操作
    }
}

上下文环境类，包含解释器之外的全局信息

package com.guifa.interpreterpatterndemo;

public class Context {
}

客户类

package com.guifa.interpreterpatterndemo;

public class Client {
    public static void main(String[] args) {
        // 根据文法对特定句子构建抽象语法树后解释
    }
}

角色介绍：
　　AbstractExpression：抽象表达式。
　　声明一个抽象的解释操作父类，并定义一个抽象的解释方法，其具体的实现在各个具体的子类解释器中完成。
　　TerminalExpression：终结符表达式。
　　实现文法中与终结符有关的解释操作。文法中每一个终结符都有一个具体的终结表达式与之对应。
　　NonterminalExpression：非终结符表达式。
　　实现文法中与非终结符有关的解释操作。
　　Context：上下文环境类。
　　包含解释器之外的全局信息。
　　Client：客户类。
　　解释表达式，构建抽象语法树，执行具体的解释操作等。

解释器模式的简单实现

解释器模式的应用范围相当广泛，一个比较常见的场景是对算术表达式的解释，如表达式“m + n + p”，如果使用解释器模式对该表达式进行解释，那么代表数字的m、n和p三个字母我们就可以看成是终结符号，而“+”这个算术运算符号则可当作非终结符号。同样地，我们可以先创建一个抽象解释器表示数学运算。

抽象的算术运算解释器 为所有解释器共性的提取

package com.guifa.interpreterpatterndemo;

public abstract class ArithmeticExpression {
    /**
     * 抽象的解析方法
     * 具体的解析逻辑由具体的子类实现
     *
     * @return 解析得到具体的值
     */
    public abstract int interpret();
}

ArithmeticExpression有两个直接子类，NumExpression和OperatorExpression，其中NumExpression用于对数字进行解释：

数字解释器 仅仅为了解释数字

package com.guifa.interpreterpatterndemo;

public class NumExpression extends ArithmeticExpression {

    private int num;

    public NumExpression(int num) {
        this.num = num;
    }

    @Override
    public int interpret() {
        return num;
    }
}

运算符号抽象解释器 为所有运算符号解释器共性的提取

package com.guifa.interpreterpatterndemo;

public abstract class OperatorExpression extends ArithmeticExpression {

    public ArithmeticExpression exp1;
    public ArithmeticExpression exp2;

    public OperatorExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        this.exp1 = exp1;
        this.exp2 = exp2;
    }
}

加法运算抽象解释器

package com.guifa.interpreterpatterndemo;

public class AdditionExpression extends OperatorExpression {

    public AdditionExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }

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

上面就是本例中所要使用的所有解释器，此外，我们还需要创建一个Calculator类来处理相关的业务。

处理与解释相关的一些业务

package com.guifa.interpreterpatterndemo;

import java.util.Stack;

public class Calculator {

    // 声明一个Stack栈存储并操作所有相关解释器
    private Stack<ArithmeticExpression> mExpStack = new Stack<>();

    public Calculator(String expression) {
        // 声明两个ArithmeticExpression类型的临时变量，存储运算符左右两边的数字解释器
        ArithmeticExpression exp1;
        ArithmeticExpression exp2;
        // 根据空格分割表达式字符串
        String[] elements = expression.split(" ");

        /**
         * 循环遍历表达式字符串
         */
        for (int i = 0; i < elements.length; i++) {
            /**
             * 判断运算符号
             */
            switch (elements[i].charAt(0)) {
                case '+': // 如果是加号
                    // 则将栈中的解释器弹出作为运算符号左边的解释器
                    exp1 = mExpStack.pop();
                    // 同时将运算符号数组下标下一个元素构造为一个数字解析器
                    exp2 = new NumExpression(Integer.valueOf(elements[++i]));
                    // 通过上面两个数字解释器构造加法运算解释器
                    mExpStack.push(new AdditionExpression(exp1, exp2));
                    break;
                default: // 如果为数字
                    /**
                     * 如果不是运算符号则为数字
                     * 若是数字，直接构造数字解释器并压入栈
                     */
                    mExpStack.push(new NumExpression(Integer.valueOf(elements[i])));
                    break;
            }
        }
    }

    public int calculate() {
        return mExpStack.pop().interpret();
    }
}

这里注意，我们约定表达式没个元素之间必须用空格隔开，如"1 + 22 + 333"，而其他均是不合法的。

package com.guifa.interpreterpatterndemo;

public class Client {
    public static void main(String[] args) {
        Calculator calculator = new Calculator("153 + 896 + 789");
        System.out.println(calculator.calculate());
    }
}

总结

优点：
　　解释器模式的优点我们在本文的例子中已有所提及，最大的优点是其灵活的扩展性，当我们想对文法规则进行扩展延伸时，只需要增加相应的非终结符解释器，并在构建抽象语法树时，使用到新增的解释器对象进行具体的解释即可，非常方便。
缺点：
　　解释器模式的缺点也显而易见，因为对于每一条文法都可以对应至少一个解释器，其会生成大量的类，导致后期维护困难；同时，对于过于复杂的文法，构建其抽象语法树会显得异常繁琐，甚至有可能会出现需要构建多棵抽象语法树的情况，因此，对于复杂的文法并不推荐使用解释器模式。