设计模式-解释器模式（Interpreter）

解释器模式是行为型模式的一种。给定一个语言(如由abcdef六个字符组成的字符串集合),定义它的文法的一种表示(S::=abA*ef,A::=cd)并定义一个解释器,解释器使用该表示来解释语言中的句子.其中的解释器类似一个翻译机

角色和职责：

1.抽象解释器（AbstractExpression）:

维护对行为实现（Implementor）的引用

2.终结符解释器（TerminalExpression） -AddExpression:

3.非终结符解释器（NonterminalExpression）-NumberExpression:

4.上下文环境（Context）:

UML图：

具体代码：

/**
 * 抽象解释器
 */
public interface AbstractExpression {
    int interptet();//处理
}

/**
 * 数字类
 */
public class NumberExpression implements AbstractExpression{
    private int number;
    public NumberExpression(int number){
        this.number = number;
    }

    @Override
    public int interptet() {
        return number;
    }
}

/**
 * 运算类
 */
public class AddExpression implements AbstractExpression{
    private AbstractExpression expression1;
    private AbstractExpression expression2;
    public AddExpression(AbstractExpression expression1,AbstractExpression expression2){
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public int interptet() {
        return expression1.interptet() + expression2.interptet();
    }
}

import java.util.Stack;

/**
 * 上下文，解释器
 *
 */
public class Context {
    Stack<AbstractExpression> stack = new Stack<AbstractExpression>();
    public Context(String str){
        String strs[] = str.split(" ");
        for(int i=0;i<strs.length;i++){
            switch (strs[i]){
                case "+":
                    AbstractExpression number1 = stack.pop();
                    AbstractExpression number2 = new NumberExpression(Integer.parseInt(strs[++i]));
                    stack.push(new AddExpression(number1,number2));
                    break;
                default:
                    stack.push(new NumberExpression(Integer.parseInt(strs[i])));
                    break;
            }
        }
    }

    public int calculate(){
        return stack.pop().interptet();//计算结果
    }
}

public class Main {
    public static void main(String[] args) {
        Context context = new Context("22 + 33 + 44");
        int result = context.calculate();//计算结果
        System.out.println("计算结果："+result);
    }
}

结果：

计算结果：99

优缺点：

优：灵活性强,如上边的例子,当我们想对文法规则进行扩展延伸时,只需要增加相应的非终结符解释器,并在构建语法树的时候使用新增的解释器对象进行具体的解释即可.

缺：因为每一条文法都可以对应至少一个解释器,会生成大量的类,导致后期维护困难,而且对应复杂的文法,构建语法树会显得异常繁琐.

源码地址：https://github.com/qjm201000/design_pattern_interpreter.git