JAVA设计模式——解释器模式

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

如果一个特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

使用：当有一个语言需要解释执行，并且可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。

缺点：解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。建议当文法非常复杂时，使用其它的技术如语法分析程序或编译器生成器来处理。

一个抽象类，实现类做相应功能，一个功能有一个具体实现类

/**
 * 抽象解释器，表示数学运算
 */
public abstract class YunSuan {
    public abstract int interpret();
}

/**
 * 加法解释器
 */
public class Addition extends Operator {
    public Addition(YunSuan yunSuan1, YunSuan yunSuan2) {
        super(yunSuan1, yunSuan2);
    }
    @Override
    public int interpret() {
        return yunSuan1.interpret() + yunSuan2.interpret();
    }
}

/**
 * 对数字进行解释
 */
public class Num extends YunSuan {
    private int num;
    public Num(int num) {
        this.num = num;
    }
    @Override
    public int interpret() {
        return num;
    }
}

/**
 * 运算符解释器
 */
public abstract class Operator extends YunSuan {
    protected YunSuan yunSuan1,yunSuan2;

    public Operator(YunSuan yunSuan1, YunSuan yunSuan2) {
        this.yunSuan1 = yunSuan1;
        this.yunSuan2 = yunSuan2;
    }
}

/**
 * 处理业务逻辑
 */
public class Calculator {
    protected Stack<YunSuan> stack = new Stack<>();

    public Calculator(String exp) {
        YunSuan yunSuan1, yunSuan2;
        String[] elements = exp.split(" ");  //用空格分割出数字和字符
        for (int i = 0; i < elements.length; i++) {
            switch (elements[i].charAt(0)){
                case '+':   //将堆中的对象取出，将新的对象放入原对象中
                    yunSuan1 = stack.pop();
                    yunSuan2 = new Num(Integer.valueOf(elements[++i]));
                    stack.push(new Addition(yunSuan1,yunSuan2));
                    break;
                default:    //将当前数字作为对象的属性，对象放入堆中
                    stack.push(new Num(Integer.valueOf(elements[i])));
                    break;
            }
        }
    }
    public int calculate(){ //最后堆中的对象是一个里面有一个对象的嵌套模式，将其两个数字相加，最后返回所有数字结果
        return stack.pop().interpret();
    }
}

/**
 * 不使用堆
 */
public class CalculatorNew {
    protected Integer res = 0;

    public CalculatorNew(String exp) {
        YunSuan yunSuan1, yunSuan2;
        String[] elements = exp.split(" ");  //用空格分割出数字和字符
        for (int i = 0; i < elements.length; i++) {
            switch (elements[i].charAt(0)){
                case '+':
                    yunSuan1 = new Num(res);
                    yunSuan2 = new Num(Integer.valueOf(elements[++i]));
                    res = new Addition(yunSuan1,yunSuan2).interpret();
                    break;
                default:
                    res = new Num(Integer.valueOf(elements[i])).interpret();
                    break;
            }
        }
    }
    public int calculate(){
        return res;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator("123 + 13 + 12 + 125");
        System.out.println(calculator.calculate());
        CalculatorNew calculatorNew = new CalculatorNew("123 + 13 + 12 + 125");
        System.out.println(calculatorNew.calculate());
    }
}