设计模式[22]-解释器模式-Interpreter Pattern

1.解释器模式简介

解释器模式(Interpreter Pattern)模式是行为型(Behavioral)设计模式，定义语言的文法，并且建立一个解释器来解释该语言的句子。

在实际应用中，很少有机会碰到去构造一个语言的文法；学习这个设计模式，也许是个投入产出比较小的行为。

Interpreter Pattern.png

如上图所示，解释器模式一共有四种角色：

(1) AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。

(2) TerminalExpression（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。

(3) NonterminalExpression（非终结符表达式）：为文法中的非终结符号实现解释操作。

(4) Context(上下文类）：用于存储解释器之外的一些全局信息，临时存储需要解释的语句。

举例：a + b = c，变量a、b是终结符表达式，+(加法)是非终结符表达式；同样，加减乘除与或非等，都是非终结符表达式。

2. 解释器模式举例

下面做个整数加减乘除运算的例子。

序号	类名	角色	说明
1	Context	Context	上下文类
2	Expression	AbstractExpression	抽象表达式
3	Constant	TerminalExpression	常量，是终结符表达式
4	Variable	TerminalExpression	变量，是终结符表达式
5	Add	NonterminalExpression	加法，是非终结符表达式
6	Subtract	NonterminalExpression	减法，是非终结符表达式
7	Multiply	NonterminalExpression	乘法，是非终结符表达式
8	Division	NonterminalExpression	除法，是非终结符表达式
9	InterpreterMain	客户端	演示调用

类图如下

Interpreter Pattern.png

1. Context 上下文类

/**
 * 上下文类
 */
public class Context {

    // 存储变量对应的值
    private Map map = new HashMap<>();

    /**
     * 给变量赋值
     *
     * @param key 变量
     * @param value 值
     */
    public void assign(Variable key, int value) {
        Integer v = new Integer(value);
        map.put(key, v);
    }

    /**
     * 查找变量的值
     *
     * @param key 变量
     * @return 值
     */
    public int lookupValue(Variable key) {
        return map.get(key);
    }

}

2.Expression 抽象表达式

/**
 * 抽象表达式
 */
public abstract class Expression {

    /**
     * 表达式的解释操作
     *
     * @param ctx 上下文
     * @return 表达式的结果
     */
    public abstract int interpret(Context ctx);

}

3. Constant，常量表达式

/**
 * 常量表达式，是终结符表达式（TerminalExpression）。
 */
public class Constant extends Expression {

    private int i;

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

    /**
     * 常量的值返回它本身
     *
     * @param ctx 上下文
     * @return 常量的值
     */
    @Override
    public int interpret(Context ctx) {
        return i;
    }
}

4. Variable，变量表达式

/**
 * 变量表达式，是终结符表达式（TerminalExpression）。
 */
public class Variable extends Expression {
    
    /**
     * 变量的值从上下文中的map中查找
     *
     * @param ctx 上下文
     * @return 变量的值
     */
    @Override
    public int interpret(Context ctx) {
        return ctx.lookupValue(this);
    }
}

5.Add，加法表达式

/**
 * 加法表达式，是非终结符表达式（NonterminalExpression）。
 */
public class Add extends Expression {

    // 被加数，加数
    private Expression augend, addend;

    /**
     * 构造器
     *
     * @param augend 被加数
     * @param addend 加数
     */
    public Add(Expression augend, Expression addend) {
        this.augend = augend;
        this.addend = addend;
    }

    /**
     * 加法语法解释
     *
     * @param ctx 上下文
     * @return 加法结果
     */
    @Override
    public int interpret(Context ctx) {
        return augend.interpret(ctx) + addend.interpret(ctx);
    }
}

6.Subtract 减法表达式

/**
 * 减法表达式，是非终结符表达式（NonterminalExpression）。
 */
public class Subtract extends Expression {

    // 被减数、减数
    private Expression minuend, subtrahend;

    /**
     * 构造器
     *
     * @param minuend    被减数
     * @param subtrahend 减数
     */
    public Subtract(Expression minuend, Expression subtrahend) {
        this.minuend = minuend;
        this.subtrahend = subtrahend;
    }

    /**
     * 减法语法解释
     *
     * @param ctx 上下文
     * @return 减法计算结果
     */
    @Override
    public int interpret(Context ctx) {
        return minuend.interpret(ctx) - subtrahend.interpret(ctx);
    }
}

7.Multiply 乘法表达式

/**
 * 乘法表达式，是非终结符表达式（NonterminalExpression）。
 */
public class Multiply extends Expression {

    // 被乘数，乘数
    private Expression multiplicand, multiplier;

    /**
     * 构造器
     *
     * @param multiplicand 被乘数
     * @param multiplier   乘数
     */
    public Multiply(Expression multiplicand, Expression multiplier) {
        this.multiplicand = multiplicand;
        this.multiplier = multiplier;
    }

    /**
     * 乘法语法解释
     *
     * @param ctx 上下文
     * @return 乘法计算结果
     */
    @Override
    public int interpret(Context ctx) {
        return multiplicand.interpret(ctx) * multiplier.interpret(ctx);
    }
}

8. Division 除法表达式

/**
 * 除法表达式，是非终结符表达式。
 */
public class Division extends Expression {

    // 被除数，除数
    private Expression dividend, divisor;

    /**
     * 构造器
     *
     * @param dividend 被除数
     * @param divisor  除数
     */
    public Division(Expression dividend, Expression divisor) {
        this.dividend = dividend;
        this.divisor = divisor;
    }

    /**
     * 除法语法解释
     *
     * @param ctx 上下文
     * @return 除法结果
     */
    @Override
    public int interpret(Context ctx) {
        try {
            return dividend.interpret(ctx) / divisor.interpret(ctx);
        } catch (ArithmeticException e) {
            System.out.println("错误，除数不能为零。");
            throw e;
        }
    }
}

9. StateMain 演示类

public class InterpreterMain {

    public static void main(String[] args) {
        // 初始化上下文
        Context ctx = new Context();
        // 设置变量、常量
        Variable a = new Variable();
        Variable b = new Variable();
        Constant c = new Constant(2);
        // 为变量赋值
        ctx.assign(a,6);
        ctx.assign(b,3);
        // 运算，(6 ÷ 3) + 2
        Expression expression = new Add(new Division(a,b),c);
        System.out.println("(6 ÷ 3) + 2 = " + expression.interpret(ctx));
    }
}

结果输出

(6 ÷ 3) + 2 = 4

3. 总结

解释器模式为自定义语言提供了一种方式，它用于组织一套语法规则，并通过语法规则来解释语言中的句子。应用开发中，没有什么机会能够使用到解释器模式，可能正则表达式、XML解析之类场景可以用到解释器模式。

扩展阅读：怎样写一个解释器 http://www.yinwang.org/blog-cn/2012/08/01/interpreter

（完）