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<Variable, Integer> 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
（完）
网友评论