Java中为自定义货币类实现健壮的加法操作

import java.util.Objects;
import java.util.Scanner;

public class Money {
    private int dollars; // 美元部分
    private int cents;   // 美分部分，通常范围在0-99

    /**
     * 默认构造函数，初始化为零
     */
    public Money() {
        this.dollars = 0;
        this.cents = 0;
    }

    /**
     * 带参数的构造函数，用于创建指定美元和美分的Money对象。
     * 内部会处理美分溢出，确保cents字段在0-99范围内。
     */
    public Money(int dollars, int cents) {
        this.dollars = dollars;
        this.cents = cents;
        // 确保美分在0-99范围内，并处理进位
        normalize();
    }

    /**
     * 构造函数，从Scanner读取字符串形式的金额（例如 "$123.45"）
     * 注意：此示例简化了错误处理和格式验证，实际应用中需要更完善的校验。
     */
    public Money(Scanner sc) {
        String token = sc.next();
        int dot = token.indexOf(".");
        if (dot != -1 && token.startsWith("$")) {
            this.dollars = Integer.parseInt(token.substring(1, dot));
            this.cents = Integer.parseInt(token.substring(dot + 1));
            normalize(); // 规范化美分
        } else {
            System.err.println("Invalid money format: " + token + ". Initializing to $0.00.");
            this.dollars = 0;
            this.cents = 0;
        }
    }

    /**
     * 规范化美分，确保其在0-99范围内，并将溢出部分进位到美元。
     */
    private void normalize() {
        if (this.cents >= 100) {
            this.dollars += this.cents / 100;
            this.cents %= 100;
        } else if (this.cents < 0) { // 处理负美分的情况，例如 -$0.50
            // 更复杂的负数处理，此处简化
            // 考虑将所有金额转换为总美分进行处理会更简单
            this.dollars += (this.cents - 99) / 100; // 例如 -50 -> -1
            this.cents = (this.cents % 100 + 100) % 100; // 例如 -50 -> 50
        }
    }

    /**
     * 返回金额的字符串表示形式，确保美分始终是两位数。
     */
    @Override
    public String toString() {
        return "$" + dollars + "." + String.format("%02d", cents);
    }

    /**
     * 比较两个Money对象是否相等。
     */
    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (other == null || getClass() != other.getClass()) return false;
        Money money = (Money) other;
        return dollars == money.dollars && cents == money == cents;
    }

    /**
     * 重写hashCode方法，与equals方法保持一致。
     */
    @Override
    public int hashCode() {
        return Objects.hash(dollars, cents);
    }

    // add 方法待实现
    public Money add(Money other) {
        // ...
        return this; // 或返回新对象
    }
}

public Money add(Money other) {
    // 1. 健壮性检查：如果传入对象为null，则不进行操作，直接返回当前对象
    if (other == null) {
        return this;
    }

    // 2. 累加美分
    this.cents += other.cents;

    // 3. 处理美分进位：如果美分总数 >= 100，则将多余部分进位到美元
    // 注意：这里假设cents不会因为加法变得过大导致溢出int，
    // 如果金额非常大，可能需要考虑long类型或BigDecimal。
    if (this.cents >= 100) {
        this.dollars += this.cents / 100; // 计算进位的美元数
        this.cents %= 100;                // 更新剩余的美分数
    }
    // 也可以调用 normalize() 方法来处理进位，前提是normalize()能处理累加后的值
    // this.dollars += other.dollars;
    // normalize();

    // 4. 累加美元
    this.dollars += other.dollars;

    // 5. 返回当前对象
    return this;
}

// 不可变版本的 add 方法
public Money addImmutable(Money other) {
    if (other == null) {
        // 对于不可变对象，通常抛出异常更合适，因为无法“不改变”地返回当前对象
        throw new IllegalArgumentException("Cannot add a null Money object.");
    }

    int newCents = this.cents + other.cents;
    int newDollars = this.dollars + other.dollars;

    // 处理美分进位
    if (newCents >= 100) {
        newDollars += newCents / 100;
        newCents %= 100;
    }
    // 注意：这里没有处理负数情况，如果需要，newCents和newDollars的计算会更复杂

    return new Money(newDollars, newCents); // 使用私有构造函数创建新对象
}