前言

解释器模式在平时基本上用不到，因此笔者也不打算花太多精力在这上面，但强迫症使然，所以翻译了GeeksForGeeks上面的一篇文章，本文采取意译及注解方式，原文链接Interpreter Pattern

译文

解释器模式是一种行为型模式，它提供一个解析特定语法规则的解释器。

• 该模式包含一个表达式接口，该表达式族用来解析一些特定的语法规则。此模式常用于sql解析、符号解析引擎等。
• 该模式执行于解析表达式上，并且每一个表达式都包含终结符和非终结符。如a + b，a、b即为终结符，+为非终结符；那么解析终结符的解释器即为终结符表达式，解析非终结符的解释器为非终结符表达式。
• 将解释器模式的结构看作树形的话，其终结符表达式就像是组合中的叶子，而非终结符表达式就像是组件一般。

看例子，这里有一个由“+ - 9 8 7”组成的表达式树：

解释器模式的类图：

由图我们可以看到解释器模式包含以下几个角色：

• 抽象表达式：声明一个包含interpreter方法的接口，所有终结符表达式或非终结符表达式需要实现该接口并重写该方法。
• 终结符表达式：重写interpreter方法解析终结符。
• 非终结符表达式：重写interpreter解析非终结符，如“+、-、*、/”等。
• Context上下文：保存全局解释器的信息（原文是用String实现，这里没有全部按照其翻译）。
• 客户端：组装表达式结构，并执行解释器方法interpreter解析表达式。

下面是代码演示简单的四则运算（因原文使用的是String来表现Context，个人感觉不太直观，体现不出Context的作用，因此引用了另一篇博文的例子——设计模式(行为型)之解释器模式(Interpreter Pattern)），首先是表达式族：

// 抽象表达式
public interface Expression {

    int interpret(Context context);
}

// 终结符表达式
public class Variable implements Expression {

    @Override
    public int interpret(Context context) {
    	// 该表达式呈现的是一个随时可更改值的表达式，因此具体值保存在context中
        return context.getValue(this);
    }

}
// 字面量值使用该表达式存储
public class Constant implements Expression {
	
    private int value;

    public Constant(int value) {
        this.value = value;
    }

    @Override
    public int interpret(Context context) {
        return value;
    }
}

// 非终结符表达式
// 加法解析器
public class AddExpression implements Expression {

    private Expression left, right;

    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}
// 减法解析器
public class SubExpression implements Expression {

    Expression left, right;

    public SubExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) - right.interpret(context);
    }
}
// 乘法解析器
public class MulExpression implements Expression {

    private Expression left, right;

    public MulExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) * right.interpret(context);
    }
}
// 除法解析器
public class DevExpression implements Expression {

    private Expression left, right;

    public DevExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        return left.interpret(context) / right.interpret(context);
    }
}

然后是Context类：

public class Context {
	// 使用Map来存储表达式和值
    private Map<Variable, Integer> map = new HashMap<>();
	
	// 将表达式和值存入map
    public void putValue(Variable x, Integer y) {
        map.put(x, y);
    }

	// 通过表达式对象获取对应的值
    public Integer getValue(Variable x) {
        return map.get(x);
    }

}

客户端测试：

    public static void main(String[] args) {
        // 首先创建变量x, y
        Variable x = new Variable();
        Variable y = new Variable();

        // 获取上下文容器，保存变量值
        Context context = new Context();
        context.putValue(x, 5);
        context.putValue(y, 10);
        // 创建常量
        Expression constant = new Constant(100);

        // 计算(x + y) * 100 / x
        Expression expression = new DevExpression(new MulExpression(new AddExpression(x, y), constant), x);
        int res = expression.interpret(context);
        System.out.println(res);
    }

通过上面的例子我们可以发现解释器模式的优点如下：

• 每个语法都实现自同一个接口，且独立，因此扩展方便，很容易修改已有规则或是扩展新的规则。
• 实现一个新的语法规则也很容易，因为所有的表达式都实现自同一个接口或继承自同一个抽象类，因此它们彼此之间都具有共通性。

解释器模式的缺点也很明显：

• 每一个语法规则就需要新定义一个类，因此对于一个具有复杂语法的语言，那么解释器模式就非常难以维护。