解释器模式（行为型）

  大家都知道，写好的代码无法直接运行，必须要经过编译后才能运行。java代码需要编译成class(java字节码)文件才能放在jvm上运行，java代码只有经过javac编译器编译后jvm才能认识。javac编译器在这里扮演的就是解释器的角色。xml解析器也是同样的道理，还有tomcat解析war包运行web项目，android中PackageManager解析apk安装app等等，都运用了解释器模式。

定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
结构：

• 抽象解释器：接口或者抽象类，具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和NonterminalExpression完成。
• 终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。
• 非终结符表达式：文法中的每条规则对应于一个非终结符表达式。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。
• 环境上下文：具体的场景

适用场景：

• 一个简单语法需要解释的场景
• 重复发生的问题可以用一种简单的语言来进行表达
• 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树

UML类图：

下面就是解释器模式的代码实现：
Expression：

public interface Expression {
    int interprete();
}

NonTerminalExpression：

public class ValueExpression implements Expression{
    private int value;
    public ValueExpression(int value){
        this.value = value;
    }
    @Override
    public int interprete() {
        return value;
    }
}

TerminalExpression：

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

public class AddExpression extends SymbolExpression {
    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }
    @Override
    public int interprete() {
        return left.interprete()+right.interprete();
    }
}

public class SubExpression extends SymbolExpression {
    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }
    @Override
    public int interprete() {
        return left.interprete()-right.interprete();
    }
}

Context：

public class Calculator {
    private Expression expression;
    public Calculator build(String content){
        Expression left,right;
        String[] strarr = content.split(" ");
        Stack stack = new Stack();
        for(int i=0;i<strarr.length;i++){
            if(strarr[i].equalsIgnoreCase("+")){
                left=(Expression)stack.pop();
                int val=Integer.parseInt(strarr[++i]);
                right=new ValueExpression(val);
                stack.push(new AddExpression(left,right));
            }
            else if(strarr[i].equalsIgnoreCase("-")){
                left=(Expression)stack.pop();
                int val=Integer.parseInt(strarr[++i]);
                right=new ValueExpression(val);
                stack.push(new SubExpression(left,right));
            }
            else{
                stack.push(new ValueExpression(Integer.parseInt(strarr[i])));
            }
        }
        this.expression = (Expression) stack.pop();
        return this;
    }
    public int calculate(){
        return expression.interprete();
    }
}

Test：

public class Test {
    public static void main(String[] args){
        String content = "1 + 3 + 4 + 7 - 8";
        int result = new Calculator().build(content).calculate();
        System.out.println(result);
    }
}

 
总结：在平常开发中解释器模式用的很少，解释器模式一般用于脚本语言解析器的编写和编译器的编写；例如xml解析器、JSON解析器、gcc编译器等等。解释器执行的效率也是很低的，所以通常我们编译一个项目都要花费一点时间。

---

参考：http://www.cnblogs.com/chenssy/p/3346427.html