引子
解释器模式应该是一个很少会用到的模式，也不太好理解，用例子的方式来讲解吧。
定义
解释器模式是类的行为模式。给定一个语言之后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。
组成结构
一个解释器模式中包含的四种角色
- 抽象解释器：声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。具体解释任务由它的各个实现类来完成，具体的解释器分别由终结符解释器和非终结符解释器完成。
- 终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。终结符一半是文法中的运算单元，比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
- 非终结符表达式：文法中的每条规则对应于一个非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，+就是非终结符，解析+的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。
- 环境角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。
类图
简单类图如下所示
例子
我们需要一个能够解释加法和减法的解释器，那么最好的方式就是用解释器模式来实现。
先来看看抽象表达式
public abstract class Expression {
/**
* 以环境为准，本方法解释给定的任何一个表达式
*/
public abstract int interpret(Context ctx);
/**
* 检验两个表达式在结构上是否相同
*/
public abstract boolean equals(Object obj);
/**
* 返回表达式的hash code
*/
public abstract int hashCode();
/**
* 将表达式转换成字符串
*/
public abstract String toString();
}
因为需要解释加法和减法，因此实现类也有Plus和Minus两个非终结符表达式
public class Plus extends Expression {
private Expression left,right;
public Plus(Expression left , Expression right){
this.left = left;
this.right = right;
}
@Override
public boolean equals(Object obj) {
if(obj != null && obj instanceof Plus)
{
return left.equals(((Plus)obj).left) &&
right.equals(((Plus)obj).right);
}
return false;
}
@Override
public int hashCode() {
return this.toString().hashCode();
}
@Override
public int interpret(Context ctx) {
return left.interpret(ctx) + right.interpret(ctx);
}
@Override
public String toString() {
return "(" + left.toString() + " + " + right.toString() + ")";
}
}
public class Minus extends Expression {
private Expression left, right;
public Minus(Expression left, Expression right) {
this.left = left;
this.right = right;
}
@Override
public boolean equals(Object obj) {
if (obj != null && obj instanceof Minus) {
return left.equals(((Minus) obj).left) && right.equals(((Minus) obj).right);
}
return false;
}
@Override
public int hashCode() {
return this.toString().hashCode();
}
@Override
public int interpret(Context ctx) {
return left.interpret(ctx) - right.interpret(ctx);
}
@Override
public String toString() {
return "(" + left.toString() + " - " + right.toString() + ")";
}
}
除此之外我们还需要变量与常量两个终结符表达式
public class Constant extends Expression{
private int value;
public Constant(int value){
this.value = value;
}
@Override
public boolean equals(Object obj) {
if(obj != null && obj instanceof Constant){
return this.value == ((Constant)obj).value;
}
return false;
}
@Override
public int hashCode() {
return this.toString().hashCode();
}
@Override
public int interpret(Context ctx) {
return value;
}
@Override
public String toString() {
return new Integer(value).toString();
}
}
public class Variable extends Expression {
private String name;
public Variable(String name){
this.name = name;
}
@Override
public boolean equals(Object obj) {
if(obj != null && obj instanceof Variable)
{
return this.name.equals(
((Variable)obj).name);
}
return false;
}
@Override
public int hashCode() {
return this.toString().hashCode();
}
@Override
public String toString() {
return name;
}
@Override
public int interpret(Context ctx) {
return ctx.lookup(this);
}
}
环境角色基本可以存放文法中各个终结符所对应的具体值，下面的类就是用一个map来负责
public class Context {
private Map<Variable,Integer> map = new HashMap<Variable,Integer>();
public void assign(Variable var , int value){
map.put(var, new Integer(value));
}
public int lookup(Variable var) throws IllegalArgumentException{
Integer value = map.get(var);
if(value == null){
throw new IllegalArgumentException();
}
return value.intValue();
}
}
Client客户端的代码
public class Client {
public static void main(String[] args) {
Context ctx = new Context();
Variable x = new Variable("x");
Variable y = new Variable("y");
Constant c = new Constant(1);
ctx.assign(x, 2);
ctx.assign(y, 3);
Expression exp = new Plus(new Plus(c,x) , new Minus(y,x));
System.out.println(exp.toString() + "=" + exp.interpret(ctx));
}
}
输出结果如下
((1 + x) + (y - x))=4
优缺点
解释器是一个简单的语法分析工具，它最显著的优点就是扩展性，修改语法规则只需要修改相应的非终结符就可以了，若扩展语法，只需要增加非终结符类就可以了。比如我们现在需要修改Plus的含义，那么只需要修改Plus类即可，如果要增加乘法操作，那么也只需要增加一个Multiple类就行。
但是，解释器模式会引起类的膨胀，每个语法都需要产生一个非终结符表达式，语法规则比较复杂时，就可能产生大量的类文件，为维护带来非常多的麻烦。同时，从例子我们也可以看到，整个表达式的运算过程采用了递归调用方法，每个非终结符表达式只关心与自己相关的表达式，每个表达式需要知道最终的结果，必须通过递归方式，无论是面向对象的语言还是面向过程的语言，递归都是一个不推荐的方式。由于使用了大量的循环和递归，效率是一个不容忽视的问题。特别是用于解释一个解析复杂、冗长的语法时，效率是难以忍受的。
使用场景
一些重复发生的事情包含固定的一系列操作类型，比较适合用解释器模式来实现。比如加减乘除四则运算，但是公式每次都不同，比如可配置，有时是a + b - c x d，有时是a x b + c - d，等等等等个，公式千变万化，但是都是由加减乘除四个非终结符来连接的，这时我们就可以使用解释器模式。
