设计模式-20解释器模式

解释器模式

基本介绍：

• 在编译原理中，一个算数表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建分析树，最终形成一颗抽象的语法分析树，这里的词法分析器和语法分析器都可以看做是解释器
• 解释器模式：是指给定一个语言，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）
• 应用场景：1。应该可以将一个需要解释执行的语言中的句子表示为一个抽象语法树2.一些重复出现的问题可以用一种简单的语言来表达3.一个简单语法需要解释的场景
• 这样例子还有如：编译器、运算表达式计算、正则表达式、机器人等

原理类图：

角色说明：

• Context：是环境角色，含有解释器之外的全局信息
• AbstractExpression：抽象表达式，声明一个抽象的解释操作，这个方法为抽象语法树中所有节点所共享
• TerminalExpression：为终结符表达式，实现了与文法中的终结符相关的解释操作
• NonTerminalExpression：为非终结表达式，为文法中的非终结符实现解释操作
• 说明：输入Context和TerminalExpression信息通过client输入即可

案例：

通过解释器模式实现：一个计算a+b-c表达式的值

/**
 * 抽象解释器表达式类
 */
public abstract class Expression {

    //解释公式和数值，key就是公式（表达式）参数[a,b,c],如：a + b - c
    //value就是具体值
    protected abstract int interpreter(HashMap<String,Integer> var);
}

/**
 * 变量解释器
 */
public class VarExpression extends Expression {
    private String key;//key =a，key=b

    public VarExpression(String key) {
        this.key = key;
    }
    //var 就是{a=10，b=20}
    //根据变量名称返回对应的值
    @Override
    protected int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);
    }
}

/**
 * 抽象符号解释器，这里每个运算符号，都只和自己左右两个数字有关系
 * 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression的实现类
 */
public abstract class SymbolExpression extends Expression{

    protected Expression left;
    protected Expression right;

    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

}

public class AddSymbolExpression extends SymbolExpression {

    public AddSymbolExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    protected int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}

public class SubSymbolExpression extends SymbolExpression {

    public SubSymbolExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    protected int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}

public class Calculator {

    private Expression expression;

    public Calculator(String expStr) {
        Stack<Expression> stack = new Stack<>();
        char[] charArray = expStr.toCharArray();

        Expression left;
        Expression right;
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]){
                case '+':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new AddSymbolExpression(left,right));
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubSymbolExpression(left,right));
                    break;
                default:
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        this.expression = stack.pop();
    }

    public int run(HashMap<String,Integer> var){
        return this.expression.interpreter(var);
    }

}


public class Client {

    public static void main(String[] args) throws Exception {
        String expStr = getExprStr();
        HashMap<String, Integer> var = getValue(expStr);
        Calculator calculator = new Calculator(expStr);

        System.out.println("运算结果：" + expStr + " = " + calculator.run(var));
    }

    private static String getExprStr() throws Exception {
        System.out.print("请输入表达式：");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    private static HashMap<String, Integer> getValue(String exprStr) throws Exception {
        HashMap<String, Integer> map = new HashMap<>();
        for (char ch : exprStr.toCharArray()) {
            if (ch != '+' && ch != '-') {
                if (!map.containsKey(String.valueOf(ch))) {
                    map.put(String.valueOf(ch), Integer.parseInt(getVar(String.valueOf(ch))));
                }
            }
        }
        return map;
    }

    private static String getVar(String var) throws Exception {
        System.out.print("请输入" + var + "的值：");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

}

解释器模式注意事项和细节：

• 当有一个语言需要解释执行，可将改语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有很好的扩展性
• 使用解释器模式可能带来的问题：解释器模式会也引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复杂、效率可能降低
• 谨慎使用，解释器模式用于处理较难的问题