java设计模式——解释器模式（Interpreter Pattern）

概述：

      解释器模式是一种使用频率相对较低但学习难度较大的设计模式，它用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解，并且掌握编程语言中文法规则的解释过程。

定义：

       解释器模式(Interpreter Pattern)：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。

结构：

• Expression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。
• TerminalExpression（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。通常在一个解释器模式中只有少数几个终结符表达式类，它们的实例可以通过非终结符表达式组成较为复杂的句子。
• NonterminalExpression（非终结符表达式）：非终结符表达式也是抽象表达式的子类，它实现了文法中非终结符的解释操作，由于在非终结符表达式中可以包含终结符表达式，也可以继续包含非终结符表达式，因此其解释操作一般通过递归的方式来完成。
• Context（环境类）：环境类又称为上下文类，它用于存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句。

UML图：

场景：比如计算长方形面积时，有相关的公式进行计算，我们只需要输入对应的参数，对应的结果会由系统计算出来。

代码分析：

/**
 * Created by yangjun on 2016/12/20.
 */

public abstract class Expression {

    /**
     *  解析公式和数值 , 其中 var 中的 key 值是是公式中的参数， value 值是具体的数字
      *  @param  var  该参数相当于 Context
     *  @return
      */
    public abstract int interpreter(HashMap<String,Integer> var);
}

/**
 * Created by yangjun on 2016/12/20.
 *  终结符类
  */

public class VarExpression  extends Expression {
    private String  m_key;
    public VarExpression(String key){
        this. m_key = key;
    }

    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get( m_key);
    }
}

/**
 * Created by yangjun on 2016/12/20.
 *  符号类
  */

public abstract class SymbolExpression  extends Expression {
    protected Expression  m_left;
    protected Expression  m_right;
    public SymbolExpression(Expression left,Expression right){
        this. m_left = left;
        this. m_right = right;
    }
}

/**
 * Created by yangjun on 2016/12/20.
 *  乘法解释器（非终结符类）
  */

public class MultiplyExpression  extends SymbolExpression {
    public MultiplyExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return super. m_left.interpreter(var) *  super. m_right.interpreter(var);
    }
}

/**
 * Created by yangjun on 2016/12/20.
 *  解释器封装类
  */

public class Calculater {

    private Expression  expression;

    public void build(String strExp){
        Expression left =  null;
        Expression right =  null;
        Stack<Expression> stack =  new Stack<Expression>();
        char[] chars = strExp.toCharArray();
        for ( int i =  0; i < chars. length; i++) {
            switch (chars[i]){
                case  '+':
                    left = stack.pop();
                    right =  new VarExpression(String. valueOf(chars[++i]));
                    stack.push( new AddExpression(left,right));
                    break;
                case  '-':
                    left = stack.pop();
                    right =  new VarExpression(String. valueOf(chars[++i]));
                    stack.push( new SubExpression(left,right));
                    break;
                case  '*':
                    left = stack.pop();
                    right =  new VarExpression(String. valueOf(chars[++i]));
                    stack.push( new MultiplyExpression(left,right));
                    break;
                case  '/':
                    left = stack.pop();
                    right =  new VarExpression(String. valueOf(chars[++i]));
                    stack.push( new DivisionExpression(left,right));
                    break;
                default:
                    stack.push( new VarExpression(String. valueOf(chars[i])));
            }
        }
        this. expression = stack.pop();
    }
    public int compute(HashMap<String, Integer> var){
        return  expression.interpreter(var);
    }

}

客户端调用：

    String strExp =  "a*b";
    Calculater calculater =  new Calculater();
    calculater.build(strExp);
    int compute = calculater.compute(rectangularArea( 2, 3));
    Log. d( "test", "compute = "+compute);
}

/**
 *  长方形面积
  *  @param  lenght
  *  @param  with
  *  @return
  */
public HashMap<String,Integer> rectangularArea( int lenght, int with){
    HashMap<String,Integer> hashMap =  new HashMap<String,Integer>();
    hashMap.put( "a",lenght);
    hashMap.put( "b",with);
    return hashMap;
}

log输出：

12-20 16:21:23.253 20582-20582/? D/test: compute = 6

优点：

• 易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
• 每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
• 实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。
• 增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。

缺点：

• 对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。
• 执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

适用场景：

• 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
• 一些重复出现的问题可以用一种简单的语言来进行表达。
• 一个语言的文法较为简单。
• 执行效率不是关键问题。【注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换成其他形式，使用解释器模式的执行效率并不高。】