DDD | 02-值对象拓展示例

示例拓展

金额和货币

创建一个表示金额和货币的值对象（AmountVO）,在系统中统一处理货币相关的数据，确保精度和一致性。

import java.math.BigDecimal;
import java.util.Currency;
 
/**
* 这个AmountVO类使用BigDecimal来精确存储金额值，避免了浮点运算可能带来的精度问题。
同时，利用Currency类来表示货币类型，确保了货币信息的标准化。
此外，重写了equals、hashCode和toString方法以支持比较、哈希运算和提供人性化的字符串表示。
*/
public class AmountVO {
 
    private final BigDecimal value; // 金额值，使用BigDecimal以精确表示货币值
    private final Currency currency; // 货币类型，使用Java标准库中的Currency类
 
    /**
     * 构造一个新的金额值对象。
     *
     * @param value   金额值，要求为正数
     * @param currency 货币类型
     */
    public AmountVO(BigDecimal value, Currency currency) {
        if (value.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Amount value must not be negative.");
        }
        this.value = value;
        this.currency = currency;
    }
 
    /**
     * 获取金额值。
     *
     * @return 金额值
     */
    public BigDecimal getValue() {
        return value;
    }
 
    /**
     * 获取货币类型。
     *
     * @return 货币类型
     */
    public Currency getCurrency() {
        return currency;
    }
 
    /**
     * 检查两个AmountVO实例是否代表相同的金额（考虑货币）。
     *
     * @param obj 另一个AmountVO实例
     * @return 如果金额和货币都相同则返回true，否则返回false
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        AmountVO amountVO = (AmountVO) obj;
        return value.equals(amountVO.value) && currency.getCurrencyCode().equals(amountVO.currency.getCurrencyCode());
    }
 
    /**
     * 生成基于金额和货币类型的哈希码。
     *
     * @return 哈希码
     */
    @Override
    public int hashCode() {
        return Objects.hash(value, currency.getCurrencyCode());
    }
 
    /**
     * 提供一个友好的字符串表示形式，包括金额和货币代码。
     *
     * @return 字符串表示形式，如 "123.45 USD"
     */
    @Override
    public String toString() {
        return value + " " + currency.getCurrencyCode();
    }
}
 

为什么金额和货币可以是值对象？

金额和货币作为值对象（Value Object）的原因在于它们符合值对象的核心特征和设计原则，具体体现在以下几个方面：

• 不可变性：金额和货币组合表示的是一个具体的、不变的值，比如“100美元”或“50欧元”。一旦创建，这个组合不应该被改变，这符合值对象通常设计为不可变对象的原则。
• 相等性基于值：两个金额和货币的组合如果数值和货币种类完全相同，就被视为相等，这与值对象的相等性定义一致，即通过其内在状态而非身份（内存地址）来判断是否相等。
• 无唯一标识：与实体对象（Entity）不同，值对象没有唯一的、持久的身份标识。无论在系统中出现多少次“100美元”，它们都是等价的，不需要区分是哪个具体的实例。
• 可共享：由于值对象表示的是不变的值，因此多个对象可以安全地共享同一个值对象实例，这有助于节省内存并简化逻辑，尤其是在表达如商品价格、账户余额等场景时。
• 封装复杂性：将金额和货币封装在一个值对象中，可以隐藏货币转换、格式化等复杂逻辑，对外提供简洁的接口，提高了代码的可读性和可维护性。
• 领域驱动设计（DDD）中的概念匹配：在领域驱动设计中，值对象用来描述没有唯一标识符但具有某种描述性的对象。金额和货币的组合正是对现实世界中经济交易的一种描述，适合用值对象来建模。

综上所述，将金额和货币设计为值对象，能够有效地提升代码的清晰度、一致性和可维护性，同时确保了在处理财务数据时的准确性和安全性。

创建一个表示价格的值对象（PriceVO）是一个很好的方式来封装和管理商品价格相关的数据，确保数据的一致性和精确计算。

import java.math.BigDecimal;
import java.util.Currency;
 
/**
* 这个PriceVO类不仅封装了价格的金额和货币类型，还提供了一个计算含税价格的方法getTaxInclusiveAmount()，并允许在构造时指定税率。
* 这样的设计使得价格的处理变得灵活且易于理解，同时也保证了在进行价格计算时的准确性和一致性。
*/
public class PriceVO {
 
    private final BigDecimal amount; // 价格金额，使用BigDecimal确保精度
    private final Currency currency; // 货币类型
    private final BigDecimal taxRate; // 税率，默认为0，表示不含税
 
    /**
     * 构造一个新的价格值对象。
     *
     * @param amount   价格金额，必须大于0
     * @param currency 货币类型
     * @param taxRate  税率，例如0.08表示8%的税率，默认为0
     */
    public PriceVO(BigDecimal amount, Currency currency, BigDecimal taxRate) {
        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("Price amount must be greater than zero.");
        }
        this.amount = amount;
        this.currency = currency;
        this.taxRate = taxRate != null ? taxRate : BigDecimal.ZERO;
    }
 
    /**
     * 获取价格金额。
     *
     * @return 价格金额
     */
    public BigDecimal getAmount() {
        return amount;
    }
 
    /**
     * 获取货币类型。
     *
     * @return 货币类型
     */
    public Currency getCurrency() {
        return currency;
    }
 
    /**
     * 获取含税价格。
     *
     * @return 含税价格
     */
    public BigDecimal getTaxInclusiveAmount() {
        if (taxRate.compareTo(BigDecimal.ZERO) > 0) {
            return amount.multiply(BigDecimal.ONE.add(taxRate));
        }
        return amount;
    }
 
    /**
     * 获取税率。
     *
     * @return 税率
     */
    public BigDecimal getTaxRate() {
        return taxRate;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PriceVO priceVO = (PriceVO) o;
        return amount.equals(priceVO.amount) &&
               currency.equals(priceVO.currency) &&
               taxRate.equals(priceVO.taxRate);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency, taxRate);
    }
 
    @Override
    public String toString() {
        return amount + " " + currency.getCurrencyCode() +
               (taxRate.compareTo(BigDecimal.ZERO) > 0 ? " (Tax: " + taxRate.multiply(new BigDecimal(100)) + "%)" : "");
    }
}
 

创建一个表示工资的值对象（SalaryVO）可以用来封装员工薪资的细节，包括基本工资、奖金、扣款等部分，并支持不同货币类型。

import java.math.BigDecimal;
import java.util.Currency;
 
/**
* 这个SalaryVO类封装了工资计算的各个方面，包括基本工资、奖金和扣款，并提供了计算总工资的方法getTotalSalary()。
* 通过使用BigDecimal类型来存储金额，确保了计算的精确度。此外，它还支持不同货币类型，增加了适用范围。
* 这样的设计使得工资数据的处理更加清晰和高效，易于维护和扩展。
*/
public class SalaryVO {
 
    private final BigDecimal baseSalary; // 基本工资
    private final BigDecimal bonus; // 奖金，默认为0
    private final BigDecimal deductions; // 扣款，默认为0
    private final Currency currency; // 货币类型
 
    /**
     * 构造一个新的工资值对象。
     *
     * @param baseSalary  基本工资，必须大于0
     * @param bonus       奖金，默认为0
     * @param deductions  扣款，默认为0
     * @param currency    货币类型
     */
    public SalaryVO(BigDecimal baseSalary, BigDecimal bonus, BigDecimal deductions, Currency currency) {
        if (baseSalary.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("Base salary must be greater than zero.");
        }
        this.baseSalary = baseSalary;
        this.bonus = bonus != null ? bonus : BigDecimal.ZERO;
        this.deductions = deductions != null ? deductions : BigDecimal.ZERO;
        this.currency = currency;
    }
 
    /**
     * 获取基本工资。
     *
     * @return 基本工资
     */
    public BigDecimal getBaseSalary() {
        return baseSalary;
    }
 
    /**
     * 获取奖金。
     *
     * @return 奖金
     */
    public BigDecimal getBonus() {
        return bonus;
    }
 
    /**
     * 获取扣款。
     *
     * @return 扣款
     */
    public BigDecimal getDeductions() {
        return deductions;
    }
 
    /**
     * 获取总工资，即基本工资加上奖金减去扣款。
     *
     * @return 总工资
     */
    public BigDecimal getTotalSalary() {
        return baseSalary.add(bonus).subtract(deductions);
    }
 
    /**
     * 获取货币类型。
     *
     * @return 货币类型
     */
    public Currency getCurrency() {
        return currency;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        SalaryVO salaryVO = (SalaryVO) o;
        return baseSalary.equals(salaryVO.baseSalary) &&
               bonus.equals(salaryVO.bonus) &&
               deductions.equals(salaryVO.deductions) &&
               currency.equals(salaryVO.currency);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(baseSalary, bonus, deductions, currency);
    }
 
    @Override
    public String toString() {
        return "Salary{" +
               "baseSalary=" + baseSalary +
               ", bonus=" + bonus +
               ", deductions=" + deductions +
               ", totalSalary=" + getTotalSalary() +
               ", currency=" + currency.getCurrencyCode() +
               '}';
    }
}
 

创建一个费用值对象（ExpenseVO）可以帮助我们统一管理和计算各种费用项，确保数据的准确性和一致性。

import java.time.LocalDate;
import java.math.BigDecimal;
import java.util.Currency;
 
/**
* 这个ExpenseVO类封装了费用的基本信息，如费用名称、金额、货币类型和发生日期，提供了获取这些属性的方法。
* 通过使用BigDecimal类型来处理金额，确保了金额计算的精确性。
* 此外，它还允许在创建时指定费用发生的特定日期，或者默认为创建时的当前日期。
* 这样的设计使得费用数据的管理更加规范和灵活。
*/
public class ExpenseVO {
 
    private final String title; // 费用标题或名称
    private final BigDecimal amount; // 费用金额，使用BigDecimal确保精度
    private final Currency currency; // 费用货币类型
    private final LocalDate date; // 费用发生日期，默认为当前日期
 
    /**
     * 构造一个新的费用值对象。
     *
     * @param title    费用标题或名称，不能为空
     * @param amount   费用金额，必须大于0
     * @param currency 费用货币类型，不能为空
     * @param date     费用发生日期，默认为当前日期
     */
    public ExpenseVO(String title, BigDecimal amount, Currency currency, LocalDate date) {
        if (title == null || title.isEmpty()) {
            throw new IllegalArgumentException("Expense title cannot be null or empty.");
        }
        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("Expense amount must be greater than zero.");
        }
        if (currency == null) {
            throw new IllegalArgumentException("Currency cannot be null.");
        }
        this.title = title;
        this.amount = amount;
        this.currency = currency;
        this.date = date != null ? date : LocalDate.now();
    }
 
    /**
     * 获取费用标题或名称。
     *
     * @return 费用标题
     */
    public String getTitle() {
        return title;
    }
 
    /**
     * 获取费用金额。
     *
     * @return 费用金额
     */
    public BigDecimal getAmount() {
        return amount;
    }
 
    /**
     * 获取货币类型。
     *
     * @return 货币类型
     */
    public Currency getCurrency() {
        return currency;
    }
 
    /**
     * 获取费用发生日期。
     *
     * @return 费用日期
     */
    public LocalDate getDate() {
        return date;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ExpenseVO expenseVO = (ExpenseVO) o;
        return title.equals(expenseVO.title) &&
               amount.equals(expenseVO.amount) &&
               currency.equals(expenseVO.currency) &&
               date.equals(expenseVO.date);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(title, amount, currency, date);
    }
 
    @Override
    public String toString() {
        return "Expense{" +
               "title='" + title + '\'' +
               ", amount=" + amount +
               ", currency=" + currency.getCurrencyCode() +
               ", date=" + date +
               '}';
    }
}
 

度量数据

创建一个重量值对象（WeightVO）可以用来封装和处理重量相关的数据，确保在系统中重量的表示和计算具有一致性和准确性

/**
* 这个WeightVO类使用BigDecimal来存储重量值，确保了数值的精确度，适用于需要高精度计算的场景。
* 同时，它定义了重量单位，使得重量的表示更加完整和明确。
* 尽管在这个基本实现中没有包含单位转换逻辑，但在实际应用中可以根据需要扩展此类，
* 增加单位之间的转换方法，以适应不同场景下的重量计量需求。
*/
 
public class WeightVO {
 
    private final BigDecimal value; // 重量值，使用BigDecimal确保精度
    private final String unit; // 重量单位，如 "kg"（千克）、"g"（克）、"lb"（磅）
 
    /**
     * 构造一个新的重量值对象。
     *
     * @param value 重量值，必须大于等于0
     * @param unit  重量单位，不能为空，建议使用标准单位
     */
    public WeightVO(BigDecimal value, String unit) {
        if (value.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Weight value must be non-negative.");
        }
        if (unit == null || unit.trim().isEmpty()) {
            throw new IllegalArgumentException("Weight unit cannot be null or empty.");
        }
        this.value = value;
        this.unit = unit.trim().toLowerCase(); // 统一单位为小写，便于比较
    }
 
    /**
     * 获取重量值。
     *
     * @return 重量值
     */
    public BigDecimal getValue() {
        return value;
    }
 
    /**
     * 获取重量单位。
     *
     * @return 重量单位
     */
    public String getUnit() {
        return unit;
    }
 
    /**
     * 检查两个WeightVO实例是否表示相同的重量（忽略单位差异）。
     *
     * @param obj 另一个WeightVO实例
     * @return 如果重量值相同则返回true，否则返回false
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        WeightVO weightVO = (WeightVO) obj;
        return value.compareTo(weightVO.value) == 0;
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
 
    /**
     * 提供一个友好的字符串表示形式，包括重量值和单位。
     *
     * @return 字符串表示形式，如 "2.5 kg"
     */
    @Override
    public String toString() {
        return value + " " + unit;
    }
}
 

创建一个长度值对象（LengthVO）旨在封装长度数据及其单位，确保在处理尺寸和距离时的精确性和一致性。

import java.math.BigDecimal;
 
/**
* 这个LengthVO类通过使用BigDecimal来存储长度值，
* 确保了数值的高精度处理，适合于需要精确测量和计算的场景。
* 同时，它定义了长度单位，使得长度的表述更为明确和规范。
* 虽然这个基本版本未包含单位转换功能，但可以根据实际需求扩展此类，
* 添加不同单位间的转换方法，以适应多样的长度计量需求。
*/
public class LengthVO {
 
    private final BigDecimal value; // 长度值，使用BigDecimal确保精度
    private final String unit; // 长度单位，如 "m"（米）、"cm"（厘米）、"in"（英寸）
 
    /**
     * 构造一个新的长度值对象。
     *
     * @param value 长度值，必须大于等于0
     * @param unit  长度单位，不能为空，建议使用标准单位
     */
    public LengthVO(BigDecimal value, String unit) {
        if (value.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Length value must be non-negative.");
        }
        if (unit == null || unit.trim().isEmpty()) {
            throw new IllegalArgumentException("Length unit cannot be null or empty.");
        }
        this.value = value;
        this.unit = unit.trim().toLowerCase(); // 统一单位为小写，便于比较
    }
 
    /**
     * 获取长度值。
     *
     * @return 长度值
     */
    public BigDecimal getValue() {
        return value;
    }
 
    /**
     * 获取长度单位。
     *
     * @return 长度单位
     */
    public String getUnit() {
        return unit;
    }
 
    /**
     * 检查两个LengthVO实例是否表示相同的长度（忽略单位差异）。
     *
     * @param obj 另一个LengthVO实例
     * @return 如果长度值相同则返回true，否则返回false
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        LengthVO lengthVO = (LengthVO) obj;
        return value.compareTo(lengthVO.value) == 0;
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
 
    /**
     * 提供一个友好的字符串表示形式，包括长度值和单位。
     *
     * @return 字符串表示形式，如 "1.5 m"
     */
    @Override
    public String toString() {
        return value + " " + unit;
    }
}
 

创建一个体积值对象（VolumeVO）用于封装和处理体积相关的数据，确保在系统中体积的表示和计算既精确又一致

import java.math.BigDecimal;
 
/**
* 这个VolumeVO类利用BigDecimal来存储体积值，确保了在处理体积数据时的高精度。
* 它还定义了体积单位，使得体积的表示更加标准化和清晰。
* 尽管此基本版本没有包含单位转换逻辑，但根据实际应用场景，
* 你可以进一步扩展此类，加入不同体积单位之间的转换方法，
* 以提高其在多场景下的适用性和便利性。
*/
public class VolumeVO {
 
    private final BigDecimal value; // 体积值，使用BigDecimal确保精度
    private final String unit; // 体积单位，如 "m³"（立方米）、"L"（升）、"gal"（加仑）
 
    /**
     * 构造一个新的体积值对象。
     *
     * @param value 体积值，必须大于等于0
     * @param unit  体积单位，不能为空，建议使用标准单位
     */
    public VolumeVO(BigDecimal value, String unit) {
        if (value.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Volume value must be non-negative.");
        }
        if (unit == null || unit.trim().isEmpty()) {
            throw new IllegalArgumentException("Volume unit cannot be null or empty.");
        }
        this.value = value;
        this.unit = unit.trim().toLowerCase(); // 统一单位为小写，便于比较
    }
 
    /**
     * 获取体积值。
     *
     * @return 体积值
     */
    public BigDecimal getValue() {
        return value;
    }
 
    /**
     * 获取体积单位。
     *
     * @return 体积单位
     */
    public String getUnit() {
        return unit;
    }
 
    /**
     * 检查两个VolumeVO实例是否表示相同的体积（忽略单位差异）。
     *
     * @param obj 另一个VolumeVO实例
     * @return 如果体积值相同则返回true，否则返回false
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        VolumeVO volumeVO = (VolumeVO) obj;
        return value.compareTo(volumeVO.value) == 0;
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
 
    /**
     * 提供一个友好的字符串表示形式，包括体积值和单位。
     *
     * @return 字符串表示形式，如 "2.5 m³"
     */
    @Override
    public String toString() {
        return value + " " + unit;
    }
}
 

范围或区间

创建一个日期范围值对象（DateRangeVO）可以用来表示起始日期和结束日期之间的一个时间区间，这对于处理时间段查询、事件安排等场景非常有用。

import java.time.LocalDate;
 
/**
* 这个DateRangeVO类使用LocalDate来表示起始和结束日期，确保了日期操作的便捷性和准确性。
* 它提供了判断日期是否在范围内、计算持续天数等实用方法，以及重写了equals和hashCode方法以支持正确的比较和哈希运算。
* 这样的设计使得处理日期范围相关的业务逻辑变得更加简单和高效。
*/
public class DateRangeVO {
 
    private final LocalDate startDate; // 起始日期，包含该日
    private final LocalDate endDate; // 结束日期，包含该日
 
    /**
     * 构造一个新的日期范围值对象。
     *
     * @param startDate 起始日期，必须不晚于结束日期
     * @param endDate   结束日期，必须不早于起始日期
     */
    public DateRangeVO(LocalDate startDate, LocalDate endDate) {
        if (startDate.isAfter(endDate)) {
            throw new IllegalArgumentException("Start date must be on or before end date.");
        }
        this.startDate = startDate;
        this.endDate = endDate;
    }
 
    /**
     * 获取起始日期。
     *
     * @return 起始日期
     */
    public LocalDate getStartDate() {
        return startDate;
    }
 
    /**
     * 获取结束日期。
     *
     * @return 结束日期
     */
    public LocalDate getEndDate() {
        return endDate;
    }
 
    /**
     * 判断给定的日期是否位于当前日期范围内。
     *
     * @param date 要检查的日期
     * @return 如果date在范围内则返回true，否则返回false
     */
    public boolean contains(LocalDate date) {
        return !date.isBefore(startDate) && !date.isAfter(endDate);
    }
 
    /**
     * 计算日期范围的持续天数。
     *
     * @return 日期范围内的天数
     */
    public long durationDays() {
        return ChronoUnit.DAYS.between(startDate, endDate) + 1; // 加1是因为两端日期都包含在内
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        DateRangeVO that = (DateRangeVO) obj;
        return startDate.equals(that.startDate) && endDate.equals(that.endDate);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(startDate, endDate);
    }
 
    /**
     * 提供一个友好的字符串表示形式，包括起始和结束日期。
     *
     * @return 字符串表示形式，如 "2023-04-01 to 2023-04-7"
     */
    @Override
    public String toString() {
        return startDate + " to " + endDate;
    }
}
 

创建一个温度区间值对象（TemperatureRangeVO）可以用来表示一个最低温度到最高温度之间的区间，这对于气象预报、工业控制等领域非常有用。

import java.math.BigDecimal;
 
/**
* 这个TemperatureRangeVO类使用BigDecimal来存储温度值，确保了温度读数的高精度。
* 它定义了温度单位，并提供了判断某个温度是否在给定区间内的方法，以及覆盖了equals和hashCode方法以支持对象的正确比较和集合操作。
* 这样的设计使得处理温度区间的数据更加方便和准确。
*/
public class TemperatureRangeVO {
 
    private final BigDecimal minValue; // 最低温度值，使用BigDecimal确保精度
    private final BigDecimal maxValue; // 最高温度值，使用BigDecimal确保精度
    private final String unit; // 温度单位，如 "C"（摄氏度）或 "F"（华氏度）
 
    /**
     * 构造一个新的温度区间值对象。
     *
     * @param minValue 最低温度值，必须小于或等于最大温度值
     * @param maxValue 最高温度值，必须大于或等于最低温度值
     * @param unit     温度单位，不能为空，建议使用标准单位
     */
    public TemperatureRangeVO(BigDecimal minValue, BigDecimal maxValue, String unit) {
        if (minValue.compareTo(maxValue) > 0) {
            throw new IllegalArgumentException("Minimum temperature must be less than or equal to maximum temperature.");
        }
        if (unit == null || unit.trim().isEmpty()) {
            throw new IllegalArgumentException("Temperature unit cannot be null or empty.");
        }
        this.minValue = minValue;
        this.maxValue = maxValue;
        this.unit = unit.trim().toUpperCase(); // 统一单位为大写，便于比较
    }
 
    /**
     * 获取最低温度值。
     *
     * @return 最低温度值
     */
    public BigDecimal getMinValue() {
        return minValue;
    }
 
    /**
     * 获取最高温度值。
     *
     * @return 最高温度值
     */
    public BigDecimal getMaxValue() {
        return maxValue;
    }
 
    /**
     * 获取温度单位。
     *
     * @return 温度单位
     */
    public String getUnit() {
        return unit;
    }
 
    /**
     * 检查给定的温度值是否位于当前温度区间内。
     *
     * @param temp 温度值
     * @return 如果温度值在区间内则返回true，否则返回false
     */
    public boolean contains(BigDecimal temp) {
        return temp.compareTo(minValue) >= 0 && temp.compareTo(maxValue) <= 0;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        TemperatureRangeVO that = (TemperatureRangeVO) obj;
        return minValue.compareTo(that.minValue) == 0 && maxValue.compareTo(that.maxValue) == 0 && unit.equals(that.unit);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(minValue, maxValue, unit);
    }
 
    /**
     * 提供一个友好的字符串表示形式，包括温度区间和单位。
     *
     * @return 字符串表示形式，如 "10°C to 25°C"
     */
    @Override
    public String toString() {
        return minValue + "°" + unit + " to " + maxValue + "°" + unit;
    }
}
 

数学模型

创建一个坐标值对象（CoordinateVO）可以用来封装二维空间中的位置信息，通常包括经度（longitude）和纬度（latitude）。

 
/**
* 这个CoordinateVO类使用double类型来存储经度和纬度值，确保了广泛的兼容性和计算简便性。
* 它验证了坐标值的有效范围，并提供了获取经度和纬度的方法。
* 通过重写equals和hashCode方法，确保了坐标值对象可以在集合中正确地进行比较和存储。
* 此外，toString方法提供了易于理解的坐标表示形式。
* 这样的设计适用于地理信息系统、地图应用等多种需要处理地理位置信息的场景。
*/
 
public class CoordinateVO {
 
    private final double longitude; // 经度
    private final double latitude; // 纬度
 
    /**
     * 构造一个新的坐标值对象。
     *
     * @param longitude 经度，取值范围通常是 -180 到 180
     * @param latitude  纬度，取值范围通常是 -90 到 90
     */
    public CoordinateVO(double longitude, double latitude) {
        if (longitude < -180 || longitude > 180) {
            throw new IllegalArgumentException("Longitude must be between -180 and 180.");
        }
        if (latitude < -90 || latitude > 90) {
            throw new IllegalArgumentException("Latitude must be between -90 and 90.");
        }
        this.longitude = longitude;
        this.latitude = latitude;
    }
 
    /**
     * 获取经度。
     *
     * @return 经度值
     */
    public double getLongitude() {
        return longitude;
    }
 
    /**
     * 获取纬度。
     *
     * @return 纬度值
     */
    public double getLatitude() {
        return latitude;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        CoordinateVO coordinateVO = (CoordinateVO) obj;
        return Double.compare(coordinateVO.longitude, longitude) == 0 && Double.compare(coordinateVO.latitude, latitude) == 0;
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(longitude, latitude);
    }
 
    /**
     * 提供一个友好的字符串表示形式，展示经纬度坐标。
     *
     * @return 字符串表示形式，如 "(100.75, 30.25)"
     */
    @Override
    public String toString() {
        return "(" + longitude + ", " + latitude + ")";
    }
}
 

创建一个向量值对象（VectorVO）可以用来表示具有大小（magnitude）和方向的量，通常在物理、工程和计算机图形学等领域中使用。这里我们以二维向量为例，它包含x分量和y分量。

 
/**
* 这个VectorVO类使用double类型来存储向量的x分量和y分量，
* 提供了获取分量值、计算向量大小（模）、向量加法和减法等基本向量操作方法。
* 同时，重写了equals和hashCode方法以支持向量对象的比较和在集合中的唯一性识别。
* toString方法则用于生成易于阅读的向量表示。
* 此实现可以作为基础，根据具体需求进一步扩展，比如添加向量的标量乘法、点积、叉积等高级操作。
*/
public class VectorVO {
 
    private final double xComponent; // x分量
    private final double yComponent; // y分量
 
    /**
     * 构造一个新的二维向量值对象。
     *
     * @param xComponent x分量
     * @param yComponent y分量
     */
    public VectorVO(double xComponent, double yComponent) {
        this.xComponent = xComponent;
        this.yComponent = yComponent;
    }
 
    /**
     * 获取x分量。
     *
     * @return x分量值
     */
    public double getXComponent() {
        return xComponent;
    }
 
    /**
     * 获取y分量。
     *
     * @return y分量值
     */
    public double getYComponent() {
        return yComponent;
    }
 
    /**
     * 计算向量的大小（模）。
     *
     * @return 向量的大小
     */
    public double magnitude() {
        return Math.sqrt(xComponent * xComponent + yComponent * yComponent);
    }
 
    /**
     * 向量加法。
     *
     * @param other 另一个向量
     * @return 两个向量相加的结果
     */
    public VectorVO add(VectorVO other) {
        return new VectorVO(this.xComponent + other.xComponent, this.yComponent + other.yComponent);
    }
 
    /**
     * 向量减法。
     *
     * @param other 另一个向量
     * @return 两个向量相减的结果
     */
    public VectorVO subtract(VectorVO other) {
        return new VectorVO(this.xComponent - other.xComponent, this.yComponent - other.yComponent);
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        VectorVO vectorVO = (VectorVO) obj;
        return Double.compare(vectorVO.xComponent, xComponent) == 0 && Double.compare(vectorVO.yComponent, yComponent) == 0;
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(xComponent, yComponent);
    }
 
    /**
     * 提供一个友好的字符串表示形式，展示向量的x和y分量。
     *
     * @return 字符串表示形式，如 "<1.5, 3.2>"
     */
    @Override
    public String toString() {
        return "<" + xComponent + ", " + yComponent + ">";
    }
}
 

创建线性回归模型（LinearRegressionModelVO）值对象

线性回归是一种统计方法，用于预测一个连续响应变量与一个或多个预测变量之间的关系。这个值对象将包括模型参数（斜率和截距）、相关系数（如R²）、训练数据集的摘要统计信息等。

import java.util.List;
 
/**
* 这个LinearRegressionModelVO类封装了线性回归模型的核心参数，
* 包括斜率、截距、R²值，以及训练数据集的特征平均值和标准差列表，
* 这有助于理解和评估模型的质量。
* 通过提供这些信息，该值对象能够支持模型的持久化、比较和调试等高级操作。
*/
public class LinearRegressionModelVO {
 
    private final double slope; // 斜率，即模型的系数
    private final double intercept; // 截距，即模型的常数项
    private final double rSquared; // R²值，模型拟合优度的度量
    private final List<Double> featureMeans; // 特征（预测变量）的平均值列表
    private final List<Double> featureStdDevs; // 特征的标准差列表
 
    /**
     * 构造一个新的线性回归模型值对象。
     *
     * @param slope         模型的斜率
     * @param intercept     模型的截距
     * @param rSquared      模型的R²值
     * @param featureMeans  特征的平均值列表
     * @param featureStdDevs 特征的标准差列表
     */
    public LinearRegressionModelVO(double slope, double intercept, double rSquared,
                                   List<Double> featureMeans, List<Double> featureStdDevs) {
        if (featureMeans == null || featureStdDevs == null || featureMeans.size() != featureStdDevs.size()) {
            throw new IllegalArgumentException("Feature means and standard deviations lists must not be null and of the same size.");
        }
        this.slope = slope;
        this.intercept = intercept;
        this.rSquared = rSquared;
        this.featureMeans = featureMeans;
        this.featureStdDevs = featureStdDevs;
    }
 
    /**
     * 获取模型的斜率。
     *
     * @return 斜率值
     */
    public double getSlope() {
        return slope;
    }
 
    /**
     * 获取模型的截距。
     *
     * @return 截距值
     */
    public double getIntercept() {
        return intercept;
    }
 
    /**
     * 获取模型的R²值。
     *
     * @return R²值
     */
    public double getRSquared() {
        return rSquared;
    }
 
    /**
     * 获取特征的平均值列表。
     *
     * @return 特征平均值列表
     */
    public List<Double> getFeatureMeans() {
        return featureMeans;
    }
 
    /**
     * 获取特征的标准差列表。
     *
     * @return 特征标准差列表
     */
    public List<Double> getFeatureStdDevs() {
        return featureStdDevs;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        LinearRegressionModelVO that = (LinearRegressionModelVO) obj;
        return Double.compare(that.slope, slope) == 0 &&
               Double.compare(that.intercept, intercept) == 0 &&
               Double.compare(that.rSquared, rSquared) == 0 &&
               featureMeans.equals(that.featureMeans) &&
               featureStdDevs.equals(that.featureStdDevs);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(slope, intercept, rSquared, featureMeans, featureStdDevs);
    }
 
    /**
     * 提供一个友好的字符串表示形式，概述模型的关键参数。
     *
     * @return 字符串表示形式，如 "Slope: 2.5, Intercept: 1.0, R²: 0.85"
     */
    @Override
    public String toString() {
        return "Slope: " + slope + ", Intercept: " + intercept + ", R²: " + rSquared;
    }
}
 

创建一个多项式回归模型值对象（PolynomialRegressionModelVO）

多项式回归是线性回归的一种扩展，允许因变量和一个或多个自变量之间的关系以多项式形式建模。这个值对象会包含多项式系数、阶次、训练数据的性能指标等信息。

import java.util.List;
 
/**
* 这个PolynomialRegressionModelVO类不仅记录了多项式回归模型的系数、阶次和R²值，
* 还包含了训练数据集的特征统计信息，有助于深入分析和复用模型。
* 它支持对复杂非线性关系的建模，广泛应用于数据分析、科学计算和机器学习领域。
*/
public class PolynomialRegressionModelVO {
 
    private final int degree; // 多项式的阶次
    private final List<Double> coefficients; // 多项式系数列表，从常数项到最高次项
    private final double rSquared; // R²值，模型拟合优度的度量
    private final List<Double> featureMeans; // 特征（自变量）的平均值列表
    private final List<Double> featureStdDevs; // 特征的标准差列表
 
    /**
     * 构造一个新的多项式回归模型值对象。
     *
     * @param degree        多项式的阶次
     * @param coefficients  多项式系数列表
     * @param rSquared      模型的R²值
     * @param featureMeans  特征的平均值列表
     * @param featureStdDevs 特征的标准差列表
     */
    public PolynomialRegressionModelVO(int degree, List<Double> coefficients, double rSquared,
                                       List<Double> featureMeans, List<Double> featureStdDevs) {
        if (coefficients == null || coefficients.isEmpty() || featureMeans == null || featureStdDevs == null ||
                featureMeans.size() != featureStdDevs.size()) {
            throw new IllegalArgumentException("Coefficients, feature means, and standard deviations must not be null or incorrectly sized.");
        }
        if (degree != coefficients.size() - 1) {
            throw new IllegalArgumentException("Degree does not match the number of coefficients provided.");
        }
        this.degree = degree;
        this.coefficients = coefficients;
        this.rSquared = rSquared;
        this.featureMeans = featureMeans;
        this.featureStdDevs = featureStdDevs;
    }
 
    /**
     * 获取多项式的阶次。
     *
     * @return 阶次
     */
    public int getDegree() {
        return degree;
    }
 
    /**
     * 获取多项式系数列表。
     *
     * @return 系数列表
     */
    public List<Double> getCoefficients() {
        return coefficients;
    }
 
    /**
     * 获取模型的R²值。
     *
     * @return R²值
     */
    public double getRSquared() {
        return rSquared;
    }
 
    /**
     * 获取特征的平均值列表。
     *
     * @return 特征平均值列表
     */
    public List<Double> getFeatureMeans() {
        return featureMeans;
    }
 
    /**
     * 获取特征的标准差列表。
     *
     * @return 特征标准差列表
     */
    public List<Double> getFeatureStdDevs() {
        return featureStdDevs;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        PolynomialRegressionModelVO that = (PolynomialRegressionModelVO) obj;
        return degree == that.degree &&
               coefficients.equals(that.coefficients) &&
               Double.compare(that.rSquared, rSquared) == 0 &&
               featureMeans.equals(that.featureMeans) &&
               featureStdDevs.equals(that.featureStdDevs);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(degree, coefficients, rSquared, featureMeans, featureStdDevs);
    }
 
    /**
     * 提供一个友好的字符串表示形式，概述模型的关键参数。
     *
     * @return 字符串表示形式，如 "Degree: 3, Coefficients: [2.5, -1.3, 0.6, 1.0], R²: 0.92"
     */
    @Override
    public String toString() {
        return "Degree: " + degree + ", Coefficients: " + coefficients + ", R²: " + rSquared;
    }
}
 

创建一个矩阵值对象（MatrixVO）

用于表示数学中的矩阵。矩阵是线性代数中的基本概念，广泛应用于计算机图形学、机器学习、工程计算等多个领域。这个值对象将能够存储矩阵的维度信息以及矩阵中的元素值。

import java.util.ArrayList;
import java.util.List;
 
/**
* 这个MatrixVO类可以用来存储和操作任意大小的矩阵，包括获取和设置特定位置的元素值。
* 通过重写equals和hashCode方法，确保了不同实例间的比较逻辑正确。
* toString方法则提供了一个易于阅读的矩阵表示形式，方便打印和调试。
* 此类设计适用于需要在软件系统中处理矩阵运算的场景，例如计算密集型应用、算法开发等。
*/
public class MatrixVO {
 
    private final int rows; // 矩阵的行数
    private final int columns; // 矩阵的列数
    private final List<List<Double>> elements; // 矩阵元素，内部列表代表每行的元素
 
    /**
     * 构造一个新的矩阵值对象。
     *
     * @param rows    矩阵的行数
     * @param columns 矩阵的列数
     * @param elements 矩阵元素列表，每个子列表代表一行
     */
    public MatrixVO(int rows, int columns, List<List<Double>> elements) {
        if (rows <= 0 || columns <= 0) {
            throw new IllegalArgumentException("Number of rows and columns must be positive.");
        }
        if (elements == null || elements.size() != rows || !elements.stream().allMatch(row -> row != null && row.size() == columns)) {
            throw new IllegalArgumentException("Elements list does not match the specified dimensions.");
        }
        this.rows = rows;
        this.columns = columns;
        this.elements = new ArrayList<>(elements); // 使用新列表以避免外部修改影响内部状态
    }
 
    /**
     * 获取矩阵的行数。
     *
     * @return 行数
     */
    public int getRows() {
        return rows;
    }
 
    /**
     * 获取矩阵的列数。
     *
     * @return 列数
     */
    public int getColumns() {
        return columns;
    }
 
    /**
     * 获取指定位置的元素值。
     *
     * @param row 行索引
     * @param column 列索引
     * @return 元素值
     */
    public double getElementAt(int row, int column) {
        return elements.get(row).get(column);
    }
 
    /**
     * 设置指定位置的元素值。
     *
     * @param row      行索引
     * @param column   列索引
     * @param value    新的元素值
     */
    public void setElementAt(int row, int column, double value) {
        elements.get(row).set(column, value);
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        MatrixVO matrixVO = (MatrixVO) obj;
        return rows == matrixVO.rows && columns == matrixVO.columns && elements.equals(matrixVO.elements);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(rows, columns, elements);
    }
 
    /**
     * 提供一个友好的字符串表示形式，展示矩阵的所有元素。
     *
     * @return 字符串表示形式，如 "[[1.0, 2.0], [3.0, 4.0]]"
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < rows; i++) {
            if (i > 0) sb.append(", ");
            sb.append("[");
            for (int j = 0; j < columns; j++) {
                if (j > 0) sb.append(", ");
                sb.append(elements.get(i).get(j));
            }
            sb.append("]");
        }
        sb.append("]");
        return sb.toString();
    }
}