Java设计模式（22）：解释器模式

最新推荐文章于 2024-07-17 14:19:40 发布

传说中的靖哥哥

最新推荐文章于 2024-07-17 14:19:40 发布

阅读量189

点赞数

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

本文链接：https://blog.csdn.net/u011976388/article/details/111404332

版权

Java设计模式专栏收录该内容

24 篇文章 1 订阅

订阅专栏

22，解释器模式（Interpreter）

22.1，问题引入_计算器问题

在界面输入计算表达式，如：a+b+c+d，然后针对每一个元素输入具体值并保存，对该表达式进行填充求值，得到结果
在固有表达式中，如果需要加入新的运算符，如* / （）等，可能会造成功能扩展困难
此时可以考虑引入解释器模式，对运算符等进行隔离，对每一种类型进行单独的解释计算

22.2，基本介绍

在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再根据语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看成是解释器
解释器模式（Interpreter Pattern）：是指给定一个语言，并定义语言的表达方式。通过定义一个解释器，使用该解释器解释该语言的一种设计
应用场景：编译器；运算表达式计算；正则表达式

22.3，类图

在这里插入图片描述

Expression：解释器模式顶层解释器接口，定义基本的解释方式
VarExpression：标准的解释器具体实现类，进行一些标准数据的解释执行，此处表示计算元素数据
SymbolExpression：非标准的具体解释器顶层抽象类，定义了非标的解释器属性，由具体非标解释器执行，该抽象类聚合解释器顶层接口，可能其他解释器进行递归解释。此处表示计算符号数据
XXXSymbolExpression：非标准的解释器具体类，提供了非标部分数据的具体解释方式，此处包括加法解释和减法解释
Calculator：解释器上下文类，对过程中的基础数据进行存储，此处进行计算及计算元素存储

22.4，代码实现

Expression：顶层解释器接口

package com.self.designmode.interpreter;

import java.util.Map;

/**
 * 解释器模式: 实现计算器, 顶层表达式接口
 * @author PJ_ZHANG
 * @create 2020-12-17 15:39
 **/
public interface Expression {

    int interpreter(Map<String, Integer> dataMap);

}

VarExpression：标准解释器类

package com.self.designmode.interpreter;

import java.util.Map;

/**
 * 解释器模式: 实现计算器, 元素解释器类
 * @author PJ_ZHANG
 * @create 2020-12-17 15:41
 **/
public class VarExpression implements Expression {

    private String name;

    public VarExpression(String name) {
        this.name = name;
    }

    @Override
    public int interpreter(Map<String, Integer> dataMap) {
        return dataMap.get(name);
    }
}

SymbolExpression：非标解释器类顶层抽象类

package com.self.designmode.interpreter;

/**
 * 解释器模式: 实现计算器, 符号解释器类
 * @author PJ_ZHANG
 * @create 2020-12-17 15:43
 **/
public abstract class SymbolExpression implements Expression {

    /**
     * 左侧元素解释器
     */
    protected Expression leftExpression;

    /**
     * 右侧元素解释器
     */
    protected Expression rightExpression;

    public SymbolExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

}

AddSymbolExpression：具体非标解释器类，加法类

package com.self.designmode.interpreter;

import java.util.Map;

/**
 * 解释器模式: 计算器问题, 符号_加法解释器
 * @author PJ_ZHANG
 * @create 2020-12-17 15:44
 **/
public class AddSymbolExpression extends SymbolExpression {

    public AddSymbolExpression(Expression leftExpression, Expression rightExpression) {
        super(leftExpression, rightExpression);
    }

    @Override
    public int interpreter(Map<String, Integer> dataMap) {
        return super.leftExpression.interpreter(dataMap) + super.rightExpression.interpreter(dataMap);
    }
}

SubSymbolExpression：具体非标解释器类，减法类

package com.self.designmode.interpreter;

import java.util.Map;

/**
 * 解释器模式: 计算器问题, 符号_减法解释器
 * @author PJ_ZHANG
 * @create 2020-12-17 15:44
 **/
public class SubSymbolExpression extends SymbolExpression {

    public SubSymbolExpression(Expression leftExpression, Expression rightExpression) {
        super(leftExpression, rightExpression);
    }

    @Override
    public int interpreter(Map<String, Integer> dataMap) {
        return super.leftExpression.interpreter(dataMap) - super.rightExpression.interpreter(dataMap);
    }
}

Calculator：上下文，计算类

package com.self.designmode.interpreter;

import java.util.Map;
import java.util.Stack;

/**
 * 解释器模式: 实现计算器, 上下文类_计算器
 * @author PJ_ZHANG
 * @create 2020-12-17 15:45
 **/
public class Calculator {

    private Expression expression;

    /**
     * 解析表达式, 生成解释器表达式, 为后续计算做准备
     * @param expressionStr 计算器串
     * @return
     */
    public void parseExpression(String expressionStr) {
        // 通过一个栈对数据进行存储
        Stack<Expression> stack = new Stack<>();
        // 转换表达式为char数组, 没有做复杂处理, 说明问题即可
        char[] charArray = expressionStr.toCharArray();
        // 遍历元素组进行处理
        for (int i = 0; i < charArray.length; i++) {
            Expression leftExpression;
            Expression rightExpression;
            switch (charArray[i]) {
                // 加法处理
                // 遍历到符号, 说明左侧已经处理(不考虑第一位+-)
                // 取左侧数据, 作为符号处理的左侧表达式
                // 取右侧元素, 作则符号处理的右侧表达式
                // 构建符号解释器, 加入栈中
                case '+':
                    leftExpression = stack.pop();
                    rightExpression = new VarExpression(charArray[++i] + "");
                    stack.push(new AddSymbolExpression(leftExpression, rightExpression));
                    break;
                // 减法处理
                // 减法同上
                case '-':
                    leftExpression = stack.pop();
                    rightExpression = new VarExpression(charArray[++i] + "");
                    stack.push(new SubSymbolExpression(leftExpression, rightExpression));
                    break;
                // 元素处理
                // 直接将元素构建表达式添加到栈中
                default:
                    stack.push(new VarExpression(charArray[i] + ""));
            }
        }
        // 最终生成的抽象语法树
        expression = stack.pop();
    }

    /**
     * 根据生成的解释器表达式, 计算最终结果
     * @param dataMap 数组的元素数据
     * @return 返回最终结果
     */
    public int getValue(Map<String, Integer> dataMap) {
        // 这部分会是一个递归处理,
        // 执行该抽象语法树, 生成最终结果
        return expression.interpreter(dataMap);
    }

}

Client：客户端

package com.self.designmode.interpreter;

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

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * @author PJ_ZHANG
 * @create 2020-12-17 15:18
 **/
public class Client {

    public static void main(String[] args) {
//        Spring提供了一个计算器, 可以直接计算
//        String str = "-1 + 2 * (3 + 4)";
//        SpelExpressionParser parser = new SpelExpressionParser();
//        Expression expression = parser.parseExpression(str);
//        System.out.println(expression.getValue());
        // 输入表达式, 按a+b-c+d等类型输入
        System.out.println("请输入表达式: eg: a+b-c+d");
        Scanner scanner = new Scanner(System.in);
        String expression = scanner.nextLine();
        Map<String, Integer> dataMap = parseExpression(expression);
        Calculator calculator = new Calculator();
        calculator.parseExpression(expression);
        System.out.println("最终结果: " + calculator.getValue(dataMap));
    }

    private static Map<String,Integer> parseExpression(String expression) {
        Map<String, Integer> dataMap = new HashMap<>(16);
        for (char c : expression.toCharArray()) {
            if (String.valueOf(c).matches("^[a-z]$")) {
                System.out.println("请输入 " + c + " 的值");
                Scanner scanner = new Scanner(System.in);
                int value = scanner.nextInt();
                dataMap.put(String.valueOf(c), value);
            }
        }
        return dataMap;
    }

}

最终生成的抽象语法树，会进行递归调用执行，如下图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GKCuZhXn-1608358951088)(E:\gitrepository\study\note\image\designMode\1608194035191.png)]

22.5，解释器模式的注意事项和细节

当一个语言需要解释执行，可将语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性，符合OCP原则
解释器模式可能为引起类膨胀，采用递归调用的方式，可能会影响程序的最终执行效率。此外解释器模式相对来讲逻辑较复杂，代码难度较大

传说中的靖哥哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java设计模式（22）：解释器模式

22，解释器模式（Interpreter）22.1，问题引入_计算器问题在界面输入计算表达式，如：a+b+c+d，然后针对每一个元素输入具体值并保存，对该表达式进行填充求值，得到结果在固有表达式中，如果需要加入新的运算符，如* / （）等，可能会造成功能扩展困难此时可以考虑引入解释器模式，对运算符等进行隔离，对每一种类型进行单独的解释计算22.2，基本介绍在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再根据语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这
复制链接

扫一扫