操作型模式之Interpreter（解釋器）模式

1.如果你期望各個類都實現一個操作，對每種不同的組合結構使用不同的操作實現，可使用Interpreter（解釋器）模式
2.舉例

//抽象表達式
public abstract class Expression {
    abstract int interpret(Context context);
    public abstract String toString();
}

//int常數類
public class Constant extends Expression{
    private int value;
     public Constant(int value){
            this.value = value;
        }
    @Override
    int interpret(Context context) {
        // TODO Auto-generated method stub
        return value;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return new Integer(value).toString();
    }

}

//int變量類
public class Variable extends Expression{

     private String name;

    public Variable(String name){
        this.name = name;
    }

    @Override
    public String toString(){
        return name;        
    }

    @Override
    int interpret(Context context) {
        // TODO Auto-generated method stub
        return context.lookup(this);
    }
}

import java.util.HashMap;
import java.util.Map;
//管理者：進行表達式賦值或者查詢
public class Context {
    private Map<Variable, Integer> map = new HashMap<Variable, Integer>();

    public void assign(Variable variable,int value){
        map.put(variable, value);
    }

    public int lookup(Variable variable) throws IllegalArgumentException{
        Integer value = map.get(variable);
        if(value == null){
            throw new IllegalArgumentException();           
        }
        return value.intValue();
    }
}

//加法運算類
public class AddExpression extends Expression{

    private Expression left,right;

    public AddExpression(Expression left , Expression right){
        this.left = left;
        this.right = right;
    }
    @Override
    int interpret(Context context) {
        // TODO Auto-generated method stub
        return left.interpret(context) + right.interpret(context);
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "(" + left.toString() + " + " + right.toString() + ")";
    }

}

//測試類
public class Test {
    public static void main(String[] args) {
        Context context = new Context();
        //變量和常數
        Variable a = new Variable("a");
        Variable b = new Variable("b");
        Constant c = new Constant(10);
        //變量賦值
        context.assign(a, 1);
        context.assign(b, 2);
        //運算
        Expression ex = new AddExpression(c, new AddExpression(a, b));

        System.out.println(a.toString() + " = " + a.interpret(context));
        System.out.println(b.toString() + " = " + b.interpret(context));
        System.out.println(ex.toString() + " = " + ex.interpret(context));
    }
}

3.總結：Interpreter（解釋器）模式的主要意圖是可以按照自己定義的組合規則幾何來組合可執行對象。該模式通常伴隨這引入變量的設計，以及Boolean或算術表達式。解釋器也經常使用解釋器來簡化新的解釋器對象的創建過程。
4.參考：http://www.cnblogs.com/java-my-life/archive/2012/06/19/2552617.html