1、解释器模式

计算一个表达式的值，比如1+2-3+4-7，单纯的定义方法或函数很难适配所有，因为数值和运算符可以有无数种组合。

//用于n个整数相加
public static int add(Integer ... arr) {
	int sum = 0;
	for (Integer i : arr) {
		sum += i;
	}
	return sum;
}

如果把运算符和数字看作一个个节点，逐个去读取和解析，则可适配所有。即定义一个解释器去解释表达式。解释器模式常用于SQL解析、符号处理引擎。主要角色：

• 抽象表达式类：接口，定义解释操作，包含一个interpret方法
• 终结符表达式类：下例中的变量或者值
• 非终结表达式类：下例中的运算符（加法、减法）
• 环境角色：传递被解释器共享的数据，解释器从这里获取值

2、案例

定义抽象表达式类，定义一个解释的方法，聚合环境类对象

//抽象角色AbstractExpression
public abstract class AbstractExpression {
    public abstract int interpret(Context context);
}

定义终结符表达式（变量类）

//终结符表达式角色 变量表达式
public class Variable extends AbstractExpression {

    private String name;

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

    @Override
    public int interpret(Context ctx) {
        return ctx.getValue(this);
    }

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

//终结符表达式角色
public class Value extends AbstractExpression {

    private int value;  

    public Value(int value) {
        this.value = value;
    }

    @Override
    public int interpret(Context context) {
        return value;
    }

    @Override
    public String toString() {
        return new Integer(value).toString();
    }
}

将左边表达式和右边表达式的结果相加

//非终结符表达式角色  加法表达式
public class Plus extends AbstractExpression {

    private AbstractExpression left;  //+号左边的表达式
    private AbstractExpression right;  // +号右边的表达式

    public Plus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
    	//将左边表达式和右边表达式的结果相加
        return left.interpret(context) + right.interpret(context);
    }

    @Override
    public String toString() {
        return "(" + left.toString() + " + " + right.toString() + ")";
    }
}

//非终结符表达式角色 减法表达式
public class Minus extends AbstractExpression {
    private AbstractExpression left;
    private AbstractExpression right;

    public Minus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
	    //将左边表达式和右边表达式的结果相减
        return left.interpret(context) - right.interpret(context);
    }

    @Override
    public String toString() {
        return "(" + left.toString() + " - " + right.toString() + ")";
    }
}

环境角色类，定义一个Map集合，用来存储变量及对应的值

//环境类
public class Context {
    private Map<Variable, Integer> map = new HashMap<Variable, Integer>();
	
	//添加变量的功能
    public void assign(Variable var, Integer value) {
        map.put(var, value);
    }

    public int getValue(Variable var) {
        Integer value = map.get(var);
        return value;
    }
}

测试类：

//测试类
public class Client {
    public static void main(String[] args) {
    	//创建环境对象
        Context context = new Context();

        Variable a = new Variable("a");
        Variable b = new Variable("b");
        Variable c = new Variable("c");
        Variable d = new Variable("d");
        Variable e = new Variable("e");
        //Value v = new Value(1);

        context.assign(a, 1);
        context.assign(b, 2);
        context.assign(c, 3);
        context.assign(d, 4);
        context.assign(e, 5);
		//获取抽象语法树对象
        AbstractExpression expression = new Minus(new Plus(new Plus(new Plus(a, b), c), d), e);
		//解释（计算）
        System.out.println(expression + "= " + expression.interpret(context));
    }
}