操作型模式之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