学习笔记【23种设计模式-第二十节：Interpreter Pattern解释器模式】

Interpreter Pattern 解释器模式

简述

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

角色

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

例子

实现四则运算：有一个类Expression，有interpreter方法，有VarExpression和SymbolExpression（类似NoTerminalExpression）继承它，Expression聚合到SymbolExpression中。SubExpression和AddExpression继承SymbolExpression（乘除这里不写了）。有个Calcullator（计算器）类，Expression聚合到其中。

Expression类：

public abstract class Expression {
    //HashMap中的key是公式的参数如a\b\c等，而value则是具体的值。总：a=10，b=20这样。
    public abstract int interpreter(HashMap<String,Integer> var);
}

VarExpression类：

//变量的解释器
public class VarExpression extends Expression{
    private String key;

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

SymbolExpression类：

public class SymbolExpression extends Expression{
    protected Expression left;
    protected Expression right;

    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
    //因为SymbolExpression是让子类类实现的，所以interpreter是个默认实现。
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return 0;
    }
}

AddExpression类：

public class AddExpression extends SymbolExpression{

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

    //处理相加
    //left.interpreter(var):返回left表达式对应的值，如a=10
    //right.interpreter(var)：返回right表达式对应的值，如b=20
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return left.interpreter(var)+right.interpreter(var);
    }
}

SubExpression类：

public class SubExpression extends SymbolExpression{
    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }

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

Calculator类：

public class Calculator {
    private Expression expression;

    public Calculator(String expStr){
        Stack<Expression> stack=new Stack<>();
        //表达式拆分成字符数组
        char[] charArray=expStr.toCharArray();

        Expression left=null;
        Expression right=null;
        //遍历字符数组，争对不同情况做不同处理
        for (int i=0;i<charArray.length;i++){
            switch (charArray[i]){
                case '+':
                    left=stack.pop();//从stack取出左表达
                    right=new VarExpression(String.valueOf(charArray[++i]));//从数组取出右表达
                    stack.push(new AddExpression(left,right));//根据left和right构建AddExpression加入stack
                    break;
                case '-':
                    left=stack.pop();
                    right=new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left,right));
                    break;
                default:
                    //如果是Var，就创建要给VarExpression对象，并push到stack
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
            }
        }
        expression=stack.pop();

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

这里就不演示了。

注意事项

• 当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性。
• 应用场景：编译器、运算表达式计算、正则表达式、机器人等。
• 使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复杂、效率可能降低。