设计模式-20解释器模式

胖柯G

墨衍会员 · AI 创作全网分发码龄10年

关注

原创 2023-07-30 15:47:30 136 阅读 AI 写同款· GEO 优化 ›

语音测试（二）音频标注（praat）通过点击红线下方的圆点进行区域划分，在区域中标注所属的类别。按住Alt+Backspace 键取消蓝色线条。阅读详情

解释器模式

基本介绍：

在编译原理中，一个算数表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建分析树，最终形成一颗抽象的语法分析树，这里的词法分析器和语法分析器都可以看做是解释器
解释器模式：是指给定一个语言，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）
应用场景：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();
    }

}