23种设计模式-解释器（加减法）

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

看示例能更直接的理解

/**
 * 抽象的算术运算解释器 为所有解释器共性的提取
 */
public abstract class ArithmeticExpression {
    public abstract int interpret();
}

/**
 * 运算符号抽象解释器 为所有运算符号解释器共性的提取
 */
public abstract class OperatorExpression extends ArithmeticExpression {
    protected ArithmeticExpression exp1,exp2;//运算符两边的解释器

    public OperatorExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        this.exp1 = exp1;
        this.exp2 = exp2;
    }
}

/**
 * 仅仅为了解释数字
 */
public class NumExpression extends ArithmeticExpression {
    private int num;

    public NumExpression(int num) {
        this.num = num;
    }

    @Override
    public int interpret() {
        return num;
    }
}

/**
 * 加法运算解释器
 */
public class AdditionExpression extends OperatorExpression {
    public AdditionExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }

    @Override
    public int interpret() {
        return exp1.interpret()+exp2.interpret();
    }
}

/**
 * 处理与解释相关的一些业务
 */
public class Calculator {
    //声明一个Stack栈存储并操作所有相关的解释器
    private Stack mExpStack = new Stack<>();

    public Calculator(String expression) {
        //运算符两边的数字解释器
        ArithmeticExpression exp1, exp2;
        //根据空格分割表达式字符串
        String[] elements = expression.split(" ");

        for (int i = 0; i < elements.length; i++) {
            switch (elements[i].charAt(0)) {
                case '+':
                    //运算符左边的
                    exp1 = mExpStack.pop();
                    //右边
                    exp2 = new NumExpression(Integer.valueOf(elements[++i]));

                    //通过上面两个数字解释器构建加法运算解释器
                    mExpStack.push(new AdditionExpression(exp1,exp2));
                    break;
                default://如果是数字
                    mExpStack.push(new NumExpression(Integer.valueOf(elements[i])));

            }
        }
    }

    /**
     * 计算结构
     * @return
     */
    public int calculate() {
        return mExpStack.pop().interpret();
    }
}

public class Client {
    public static void main(String[] args) {
        Calculator c = new Calculator("153 + 3589 + 118 + 555");
        Log.e(String.valueOf(c.calculate()));
    }
}

如果需要新增减法运算，只需新建减法运算解释器并在Calculator里增加case ‘-’分支

/**
 * 减法运算解释器
 */
public class SubtractionExpression extends OperatorExpression {
    public SubtractionExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }

    @Override
    public int interpret() {
        return exp1.interpret() - exp2.interpret();
    }
}

=====================
case '-:
                    //运算符左边的
                    exp1 = mExpStack.pop();
                    //右边
                    exp2 = new NumExpression(Integer.valueOf(elements[++i]));

                    //通过上面两个数字解释器构建加法运算解释器
                    mExpStack.push(new SubtractionExpression(exp1,exp2));
                    break;