解释器模式（行为型）

  大家都知道，写好的代码放到无法直接运行，必须要经过编译后才能运行。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