赞
踩
// 定义表达式和项(term)的接口和具体实现 // 抽象表达式接口 interface Expression { double interpret(); } // 抽象项接口 interface Term extends Expression { Expression getLeftOperand(); Expression getRightOperand(); void setLeftOperand(Expression leftOperand); void setRightOperand(Expression rightOperand); } // 数字项(直接数值) class NumberTerm implements Expression { private double value; public NumberTerm(double value) { this.value = value; } @Override public double interpret() { return value; } } // 二元运算符项(加、减、乘、除) class BinaryOperatorTerm implements Term { private Expression leftOperand; private Expression rightOperand; private char operator; public BinaryOperatorTerm(char operator) { this.operator = operator; } @Override public Expression getLeftOperand() { return leftOperand; } @Override public void setLeftOperand(Expression leftOperand) { this.leftOperand = leftOperand; } @Override public Expression getRightOperand() { return rightOperand; } @Override public void setRightOperand(Expression rightOperand) { this.rightOperand = rightOperand; } @Override public double interpret() { switch (operator) { case '+': return leftOperand.interpret() + rightOperand.interpret(); case '-': return leftOperand.interpret() - rightOperand.interpret(); case '*': return leftOperand.interpret() * rightOperand.interpret(); case '/': if (rightOperand.interpret() == 0) { throw new ArithmeticException("Division by zero"); } return leftOperand.interpret() / rightOperand.interpret(); default: throw new UnsupportedOperationException("Unsupported operator: " + operator); } } } // 需要一个解析器来将字符串表达式转换为表达式树 // 表达式解析器(这里为了简化,我们假设输入是格式良好的) class ExpressionParser { // 解析方法(这里仅作为示例,真实情况下需要更复杂的解析逻辑) public Expression parse(String expression) { // 简化解析逻辑,使用堆栈实现,此处略 // ... // 示例:直接构造一个表达式树 BinaryOperatorTerm add = new BinaryOperatorTerm('+'); NumberTerm two = new NumberTerm(2); NumberTerm three = new NumberTerm(3); BinaryOperatorTerm multiply = new BinaryOperatorTerm('*'); NumberTerm four = new NumberTerm(4); NumberTerm one = new NumberTerm(1); BinaryOperatorTerm subtract = new BinaryOperatorTerm('-'); subtract.setLeftOperand(four); subtract.setRightOperand(one); multiply.setLeftOperand(three); multiply.setRightOperand(subtract); add.setLeftOperand(two); add.setRightOperand(multiply); return add; } } // 使用解析器来解析表达式并计算结果 public class Calculator { public static void main(String[] args) { ExpressionParser parser = new ExpressionParser(); Expression expression = parser.parse("2 + 3 * (4 - 1)"); // 这里我们假设parse方法已经正确实现了 double result = expression.interpret(); System.out.println("Result: " + result); // 应该输出 "Result: 11.0" } }
Result: 11.0
import java.util.HashMap; import java.util.Map; // 定义抽象表达式接口和上下文类 // 抽象表达式接口 interface Expression { Object interpret(Context context); } // 上下文类,用于存储解释器可能需要的数据 class Context { private Map<String, Object> variables = new HashMap<>(); public void setVariable(String name, Object value) { variables.put(name, value); } public Object getVariable(String name) { return variables.get(name); } } // 定义具体的表达式类 // 数值表达式 class NumberExpression implements Expression { private double value; public NumberExpression(double value) { this.value = value; } @Override public Object interpret(Context context) { return value; } } // 变量表达式 class VariableExpression implements Expression { private String name; public VariableExpression(String name) { this.name = name; } @Override public Object interpret(Context context) { return context.getVariable(name); } } // 加法表达式 class AddExpression implements Expression { private Expression left; private Expression right; public AddExpression(Expression left, Expression right) { this.left = left; this.right = right; } @Override public Object interpret(Context context) { double leftValue = (double) left.interpret(context); double rightValue = (double) right.interpret(context); return leftValue + rightValue; } } // 其他运算表达式(如减法、乘法、除法)可以类似地定义 // ... // 订单项表达式(包含数量和单价) class OrderItemExpression implements Expression { private Expression quantity; private Expression price; public OrderItemExpression(Expression quantity, Expression price) { this.quantity = quantity; this.price = price; } @Override public Object interpret(Context context) { double qty = (double) quantity.interpret(context); double priceValue = (double) price.interpret(context); return qty * priceValue; // 计算订单项总价 } } // 创建一个解析器类来解析DSL字符串,并构建表达式树 class DSLParser { // 假设这里有一个复杂的解析算法,可以将DSL字符串转换为Expression对象树 // ... // 示例方法,用于演示如何构建表达式树 public Expression parseOrderDSL(String dsl) { // 假设dsl是 "item(2, 10) + item(3, 5)",表示两个订单项,第一个数量为2,单价为10;第二个数量为3,单价为5 // 这里为了简单起见,直接构建表达式树 return new AddExpression( new OrderItemExpression(new NumberExpression(2), new NumberExpression(10)), new OrderItemExpression(new NumberExpression(3), new NumberExpression(5)) ); } } public class OrderProcessor { public static void main(String[] args) { DSLParser parser = new DSLParser(); Expression orderExpr = parser.parseOrderDSL("item(2, 10) + item(3, 5)"); Context context = new Context(); // 在这里可以设置一些全局变量或环境信息,如果有需要的话 double total = (double) orderExpr.interpret(context); System.out.println("Order total: " + total); // 输出 "Order total: 35.0" } }
Order total: 35.0
在Java JDK中,解释器模式的一个典型应用是Java的正则表达式库,特别是java.util.regex包下的相关类。这些类提供了一个强大的工具集,用于解析、匹配和操作文本字符串,它们正是基于解释器模式设计的。
模式 | 类型 | 目的 | 模式架构核心角色 | 应用场景 |
---|---|---|---|---|
迭代器模式 | 行为型 | 用于解析和处理特定语法或表达式的语言 | 抽象表达式(Expression)、具体表达式(ConcreteExpression)、环境(Context) | 当需要一种语言,该语言的解释程序可以用程序来扩展或修改时 |
状态模式 | 行为型 | 消除因多种状态导致的复杂条件判断语句,使程序更加清晰和易于维护 | 上下文(Context)、抽象状态(State)、具体状态(ConcreteState) | 当一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为时 |
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。