设计模式-解释器模式

最新推荐文章于 2024-09-26 16:41:53 发布

焦虑的二狗

最新推荐文章于 2024-09-26 16:41:53 发布

阅读量178

点赞数

分类专栏：设计模式文章标签：设计模式解释器模式 java

本文链接：https://blog.csdn.net/qq_36364521/article/details/126356636

版权

设计模式专栏收录该内容

26 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何利用解释器模式设计并实现一个简单的数学表达式解释器。通过创建不同的解释器类来表示加法和乘法操作，以及数字，然后利用栈来解析和计算字符串形式的数学表达式，例如'610011+*'。解释器模式允许在运行时组合和解释语言元素，使得语法变化和扩展更加灵活。示例中展示了如何将该模式应用于计算给定输入字符串的最终结果。

摘要由CSDN通过智能技术生成

定义

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

为了解释一种语言，而为语言创建的解释器

类型

行为型

使用场景

在某个特定类型问题发生频率足够高时

优点：

语法由很多类表示，容易改变及扩展此“语言”

缺点：

当语法规则数目太多时，增加了系统复杂性

coding

public interface Interpreter {

    int interpret();

}

public class AddInterpreter implements Interpreter {

    private Interpreter firstExpression,secondExpression;

    public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return this.firstExpression.interpret() + this.secondExpression.interpret();
    }

    @Override
    public String toString() {
        return "+";
    }
}

public class MultiInterpreter implements Interpreter {

    private Interpreter firstExpression,secondExpression;

    public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return this.firstExpression.interpret() * this.secondExpression.interpret();
    }

    @Override
    public String toString() {
        return "*";
    }
}

public class NumberInterpreter implements Interpreter {

    private int number;

    public NumberInterpreter(int number) {
        this.number = number;
    }

    public NumberInterpreter(String number) {
        this.number = Integer.parseInt(number);
    }

    @Override
    public int interpret() {
        return this.number;
    }

}

public class OperatorUtil {

    public static boolean isOperator(String symbol) {
        return (symbol.equals("+") || symbol.equals("*"));
    }

    public static Interpreter getExpressionObject(Interpreter firstExpression, Interpreter secondExpression, String symbol){
        if (symbol.equals("+")) {
            return new AddInterpreter(firstExpression, secondExpression);
        } else if (symbol.equals("*")) {
            return new MultiInterpreter(firstExpression, secondExpression);
        }
        return null;
    }
}

import java.util.Stack;

public class GeelyExpressionParser {

    private Stack<Interpreter> stack = new Stack<>();

    public int parse(String str){
        String[] strIntemArray = str.split(" ");
        for (String symbol : strIntemArray) {
            if (!OperatorUtil.isOperator(symbol)) {
                NumberInterpreter numberInterpreter = new NumberInterpreter(symbol);
                stack.push(numberInterpreter);
                System.out.println(String.format("入栈: %d", numberInterpreter.interpret()));
            } else {
                Interpreter firstExpression = stack.pop();
                Interpreter secondExpression = stack.pop();
                System.out.println(String.format("出栈： %d 和 %d", firstExpression.interpret(), secondExpression.interpret()));
                Interpreter operator = OperatorUtil.getExpressionObject(firstExpression, secondExpression, symbol);
                int result = operator.interpret();
                NumberInterpreter resultInterpreter = new NumberInterpreter(result);
                stack.push(resultInterpreter);
                System.out.println(String.format("阶段结果入栈：%d", resultInterpreter.interpret()));
            }
        }
        int result = stack.pop().interpret();
        return result;
    }

}

public class Test {

    public static void main(String[] args) {
        String geelyInputStr = "6 100 11 + *";
        GeelyExpressionParser expressionParser = new GeelyExpressionParser();
        int result = expressionParser.parse(geelyInputStr);
        System.out.println("解释器计算结果：" + result);
    }

}

源码中的使用

1、java.util.Pattern
2、Spring的el表达式，eg：

import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class Test {

    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression("100 * 2 + 400 * 1 + 66");
        Integer result = (Integer)expression.getValue();
        System.out.println(result);
    }

}