Java设计模式之行为型模式(解释器模式)实现方式详解

解释器模式是一种行为型设计模式,用于定义一种语言的文法,并且构建一个解释器来解释该语言中的句子。这种模式常用于处理简单语言的语法解析。

下面是一个简单的例子,使用Java实现一个基本的四则运算表达式求值器(仅支持加减乘除和括号)。

示例场景:

我们希望创建一个简单的数学表达式求值器,它可以解析并计算像 "3 + 5 * (10 - 4)" 这样的字符串表达式。

解释器模式的核心组件包括:

  • 抽象表达式(Abstract Expression): 声明一个抽象的解释操作。
  • 终结符表达式(Terminal Expression): 实现与文法规则中终结符相关的解释操作。
  • 非终结符表达式(Nonterminal Expression): 为文法规则中的非终结符声明一个解释操作。
  • 上下文(Context): 包含解释器之外的一些全局信息。

下面是具体的代码实现:

java 复制代码
import java.util.Stack;
// 抽象表达式接口
interface Expression {
    int interpret();
}
// 终结符表达式:数字
class NumberExpression implements Expression {
    private final int number;
    public NumberExpression(int number) {
        this.number = number;
    }
    @Override
    public int interpret() {
        return number;
    }
}
// 非终结符表达式基类:二元操作符
abstract class BinaryOperation implements Expression {
    protected final Expression leftOperand;
    protected final Expression rightOperand;
    public BinaryOperation(Expression leftOperand, Expression rightOperand) {
        this.leftOperand = leftOperand;
        this.rightOperand = rightOperand;
    }
}
// 加法操作
class AddExpression extends BinaryOperation {
    public AddExpression(Expression leftOperand, Expression rightOperand) {
        super(leftOperand, rightOperand);
    }
    @Override
    public int interpret() {
        return leftOperand.interpret() + rightOperand.interpret();
    }
}
// 减法操作
class SubtractExpression extends BinaryOperation {
    public SubtractExpression(Expression leftOperand, Expression rightOperand) {
        super(leftOperand, rightOperand);
    }
    @Override
    public int interpret() {
        return leftOperand.interpret() - rightOperand.interpret();
    }
}
// 乘法操作
class MultiplyExpression extends BinaryOperation {
    public MultiplyExpression(Expression leftOperand, Expression rightOperand) {
        super(leftOperand, rightOperand);
    }
    @Override
    public int interpret() {
        return leftOperand.interpret() * rightOperand.interpret();
    }
}
// 除法操作
class DivideExpression extends BinaryOperation {
    public DivideExpression(Expression leftOperand, Expression rightOperand) {
        super(leftOperand, rightOperand);
    }
    @Override
    public int interpret() {
        if (rightOperand.interpret() == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return leftOperand.interpret() / rightOperand.interpret();
    }
}
public class InterpreterPatternDemo {
    // 表达式的解析方法
    public static Expression parse(String expression) {
        Stack stack = new Stack<>();
        String[] tokens = expression.split("\\s+");
        for (String token : tokens) {
            switch (token) {
                case "+":
                    Expression addRight = stack.pop();
                    Expression addLeft = stack.pop();
                    stack.push(new AddExpression(addLeft, addRight));
                    break;
                case "-":
                    Expression subRight = stack.pop();
                    Expression subLeft = stack.pop();
                    stack.push(new SubtractExpression(subLeft, subRight));
                    break;
                case "*":
                    Expression mulRight = stack.pop();
                    Expression mulLeft = stack.pop();
                    stack.push(new MultiplyExpression(mulLeft, mulRight));
                    break;
                case "/":
                    Expression divRight = stack.pop();
                    Expression divLeft = stack.pop();
                    stack.push(new DivideExpression(divLeft, divRight));
                    break;
                default:
                    stack.push(new NumberExpression(Integer.parseInt(token)));
                    break;
            }
        }
        return stack.pop();
    }
    public static void main(String[] args) {
        String expression = "3 + 5 * (10 - 4)";
        Expression parsedExpression = parse(expression.replaceAll("\\(", "").replaceAll("\\)", ""));
        System.out.println("Parsed expression: " + expression);
        System.out.println("Result: " + parsedExpression.interpret());
    }
}

说明:

在这个例子中,我们实现了四种基本的操作:加、减、乘、除。每个操作都被表示为一个实现了 Expression 接口的具体类。通过栈的数据结构,我们可以方便地对表达式进行解析和计算。

相关推荐
毕设源码-赖学姐11 分钟前
【开题答辩全过程】以 SpringMVC在筑原平面设计定制管理信息系统的应用与实践为例,包含答辩的问题和答案
java·eclipse
程序定小飞35 分钟前
基于springboot的蜗牛兼职网的设计与实现
java·数据库·vue.js·spring boot·后端·spring
咖啡Beans1 小时前
RestTemplate调用API的常用写法
java·spring boot·网络协议
RickyWasYoung1 小时前
【笔记】非线性状态空间方程线性化时为什么要以平衡点为基准?
笔记
进击的圆儿1 小时前
【学习笔记02】C++面向对象编程核心技术详解
c++·笔记·学习
卷Java1 小时前
预约记录关联查询接口说明
java·开发语言·spring boot·python·微信小程序
寻星探路1 小时前
Java EE初阶启程记12---synchronized 原理
java·java-ee
qq_574656251 小时前
java代码随想录day50|图论理论基础
java·算法·leetcode·图论
蒋星熠1 小时前
Maven项目管理与构建自动化完全指南
java·前端·python·自动化·maven
sheji34161 小时前
【开题答辩全过程】以 ssm框架的智能校园服务系统为例,包含答辩的问题和答案
java·eclipse