一、价格管理的核心对象选择

在Java应用中处理价格数据时，核心对象的选择直接影响系统的精度、可维护性和扩展性。对于菜单价格这类需要精确计算的场景，推荐采用以下三种对象方案：

1.1 BigDecimal的精准控制

import java.math.BigDecimal;
import java.math.RoundingMode;
public class MenuItem {
    private BigDecimal price;
    public MenuItem(double value) {
        // 推荐构造方式：使用字符串避免浮点误差
        this.price = new BigDecimal(String.valueOf(value));
    }
    public BigDecimal getPrice() {
        return price;
    }
    public void applyDiscount(BigDecimal rate) {
        // 四舍五入保留两位小数
        price = price.multiply(rate)
                    .setScale(2, RoundingMode.HALF_UP);
    }
}

BigDecimal的优势在于：

• 精确的十进制运算，避免float/double的二进制误差
• 可配置的舍入模式（RoundingMode）
• 明确的精度控制（setScale方法）
• 不可变对象特性保证线程安全

1.2 自定义Price类的扩展性

public class Price {
    private final BigDecimal value;
    private final String currency;
    private final LocalDate validFrom;
    public Price(BigDecimal value, String currency) {
        this(value, currency, LocalDate.now());
    }
    // 构造方法、getter及业务方法...
    public boolean isGreaterThan(Price other) {
        return this.value.compareTo(other.value) > 0;
    }
}

自定义类的优势：

• 封装业务逻辑（如价格比较、有效期验证）
• 集成货币类型、生效时间等元数据
• 便于扩展（添加税费计算、折扣策略等）
• 类型安全（避免直接操作BigDecimal）

1.3 货币对象（Money Pattern）

public class Money {
    private final BigDecimal amount;
    private final Currency currency;
    public static Money of(BigDecimal amount, Currency currency) {
        return new Money(amount, currency);
    }
    public Money add(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch");
        }
        return new Money(amount.add(other.amount), currency);
    }
    // 其他运算方法...
}

货币模式的优势：

• 强制货币类型检查
• 安全的运算操作
• 符合领域驱动设计（DDD）原则
• 便于国际化支持

二、菜单价格系统的实现策略

2.1 基础菜单项设计

public class MenuItem {
    private final String name;
    private final Price basePrice;
    private List<PriceModifier> modifiers;
    public BigDecimal calculateTotal() {
        BigDecimal total = basePrice.getValue();
        for (PriceModifier modifier : modifiers) {
            total = modifier.apply(total);
        }
        return total;
    }
}

2.2 价格修饰模式实现

public interface PriceModifier {
    BigDecimal apply(BigDecimal original);
}
public class DiscountModifier implements PriceModifier {
    private final BigDecimal rate;
    public DiscountModifier(BigDecimal rate) {
        this.rate = rate; // 0.9表示9折
    }
    @Override
    public BigDecimal apply(BigDecimal original) {
        return original.multiply(rate)
                      .setScale(2, RoundingMode.HALF_UP);
    }
}

2.3 组合模式处理复杂菜单

public class MenuComposite implements MenuItem {
    private List<MenuItem> items;
    @Override
    public BigDecimal calculateTotal() {
        return items.stream()
                  .map(MenuItem::calculateTotal)
                  .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

三、最佳实践建议

3.1 精度控制策略

• 始终使用字符串构造BigDecimal
• 统一设置舍入模式（推荐HALF_UP）
• 避免在循环中进行多次舍入

3.2 线程安全设计

public class ThreadSafePrice {
    private final AtomicReference<Price> currentPrice;
    public void updatePrice(Price newPrice) {
        currentPrice.set(newPrice);
    }
}

3.3 性能优化方案

• 对频繁计算的价格使用缓存
• 考虑使用原始类型进行中间计算（需谨慎）
• 批量处理时重用BigDecimal对象

四、常见问题解决方案

4.1 浮点误差处理

// 错误示例
double a = 0.1;
double b = 0.2;
System.out.println(a + b); // 输出0.30000000000000004
// 正确方案
BigDecimal c = new BigDecimal("0.1");
BigDecimal d = new BigDecimal("0.2");
System.out.println(c.add(d)); // 输出0.30

4.2 货币转换实现

public class CurrencyConverter {
    private Map<Currency, BigDecimal> rates;
    public Money convert(Money amount, Currency target) {
        BigDecimal rate = rates.getOrDefault(target, BigDecimal.ONE);
        return Money.of(amount.getAmount()
                       .multiply(rate), target);
    }
}

4.3 历史价格追踪

public class PriceHistory {
    private Map<LocalDate, Price> records;
    public Price getPriceAt(LocalDate date) {
        return records.entrySet().stream()
                     .filter(e -> !e.getKey().isAfter(date))
                     .max(Map.Entry.comparingByKey())
                     .map(Map.Entry::getValue)
                     .orElseThrow();
    }
}

五、扩展应用场景

5.1 动态定价系统

public interface PricingStrategy {
    Price calculate(Context context);
}
public class DynamicPricing {
    private Map<String, PricingStrategy> strategies;
    public Price evaluate(String strategyId, Context context) {
        return strategies.get(strategyId).calculate(context);
    }
}

5.2 多级菜单定价

public class TieredMenu {
    private Map<Integer, Price> tierPrices; // 层级到价格的映射
    public Price getPriceForLevel(int level) {
        return tierPrices.getOrDefault(
            Math.min(level, tierPrices.size() - 1),
            tierPrices.get(tierPrices.size() - 1)
        );
    }
}

5.3 价格验证框架

public class PriceValidator {
    private List<Predicate<Price>> rules;
    public boolean validate(Price price) {
        return rules.stream().allMatch(r -> r.test(price));
    }
    // 常用规则示例
    public static Predicate<Price> positive() {
        return p -> p.getValue().compareTo(BigDecimal.ZERO) > 0;
    }
}

六、总结与建议

1. 精度优先：金融计算必须使用BigDecimal，避免浮点数误差
2. 封装业务：将价格逻辑封装在专用类中，提高可维护性
3. 模式应用：根据场景选择修饰模式、策略模式等设计模式
4. 线程安全：多线程环境下注意对象的不可变性或同步机制
5. 扩展考虑：预留货币转换、历史价格等功能的扩展接口

实际应用中，建议从简单的BigDecimal实现开始，随着业务复杂度增加，逐步引入自定义Price类和设计模式。对于大型系统，可考虑将价格计算模块独立为微服务，通过REST API或gRPC提供定价服务。