public class Address {
    private final StreetAddress street;
    private final City city;
    private final State state;
    private final ZipCode zipCode;
    
    public Address(StreetAddress street, City city, State state, ZipCode zipCode) {
        this.street = street;
        this.city = city;
        this.state = state;
        this.zipCode = zipCode;
    }
}

/**
 * 金额值对象
 * 不可变，基于值比较，包含丰富的行为
 */
public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    private static final int DEFAULT_SCALE = 2;
    private static final RoundingMode DEFAULT_ROUNDING = RoundingMode.HALF_UP;
    
    /**
     * 构造金额
     */
    public Money(BigDecimal amount, Currency currency) {
        if (amount == null) {
            throw new IllegalArgumentException("Amount cannot be null");
        }
        if (currency == null) {
            throw new IllegalArgumentException("Currency cannot be null");
        }
        this.amount = amount.setScale(DEFAULT_SCALE, DEFAULT_ROUNDING);
        this.currency = currency;
    }
    
    public Money(double amount, Currency currency) {
        this(BigDecimal.valueOf(amount), currency);
    }
    
    public Money(String amount, Currency currency) {
        this(new BigDecimal(amount), currency);
    }
    
    /**
     * 零金额
     */
    public static Money zero(Currency currency) {
        return new Money(BigDecimal.ZERO, currency);
    }
    
    /**
     * 加法
     */
    public Money add(Money other) {
        checkSameCurrency(other);
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    /**
     * 减法
     */
    public Money subtract(Money other) {
        checkSameCurrency(other);
        return new Money(this.amount.subtract(other.amount), this.currency);
    }
    
    /**
     * 乘法
     */
    public Money multiply(int multiplier) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(multiplier)), this.currency);
    }
    
    public Money multiply(BigDecimal multiplier) {
        return new Money(this.amount.multiply(multiplier).setScale(DEFAULT_SCALE, DEFAULT_ROUNDING), this.currency);
    }
    
    /**
     * 除法
     */
    public Money divide(int divisor) {
        if (divisor == 0) {
            throw new ArithmeticException("Division by zero");
        }
        return new Money(this.amount.divide(BigDecimal.valueOf(divisor), DEFAULT_SCALE, DEFAULT_ROUNDING), this.currency);
    }
    
    /**
     * 是否为零
     */
    public boolean isZero() {
        return this.amount.compareTo(BigDecimal.ZERO) == 0;
    }
    
    /**
     * 是否为正
     */
    public boolean isPositive() {
        return this.amount.compareTo(BigDecimal.ZERO) > 0;
    }
    
    /**
     * 是否为负
     */
    public boolean isNegative() {
        return this.amount.compareTo(BigDecimal.ZERO) < 0;
    }
    
    /**
     * 取绝对值
     */
    public Money abs() {
        return new Money(this.amount.abs(), this.currency);
    }
    
    /**
     * 比较
     */
    public int compareTo(Money other) {
        checkSameCurrency(other);
        return this.amount.compareTo(other.amount);
    }
    
    public boolean isGreaterThan(Money other) {
        return compareTo(other) > 0;
    }
    
    public boolean isLessThan(Money other) {
        return compareTo(other) < 0;
    }
    
    private void checkSameCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException(
                "Cannot operate on different currencies: " + this.currency + " vs " + other.currency
            );
        }
    }
    
    /**
     * 格式化输出
     */
    public String format() {
        NumberFormat formatter = NumberFormat.getCurrencyInstance(Locale.US);
        formatter.setCurrency(currency);
        return formatter.format(amount);
    }
    
    // 基于值的相等性
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Money money = (Money) o;
        return amount.compareTo(money.amount) == 0 && currency.equals(money.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
    
    @Override
    public String toString() {
        return amount + " " + currency.getCurrencyCode();
    }
    
    // Getters
    public BigDecimal getAmount() { return amount; }
    public Currency getCurrency() { return currency; }
}

from dataclasses import dataclass
import re


@dataclass(frozen=True)
class ZipCode:
    """值对象：邮政编码"""
    value: str
    
    def __post_init__(self):
        # 美国邮编格式：12345 或 12345-6789
        if not re.match(r'^\d{5}(-\d{4})?$', self.value):
            raise ValueError(f"Invalid ZIP code format: {self.value}")
    
    def __str__(self):
        return self.value


@dataclass(frozen=True)
class City:
    """值对象：城市"""
    name: str
    
    def __post_init__(self):
        if not self.name or len(self.name.strip()) == 0:
            raise ValueError("City name cannot be empty")
        if len(self.name) > 100:
            raise ValueError("City name too long")
    
    def __str__(self):
        return self.name


@dataclass(frozen=True)
class State:
    """值对象：州/省"""
    code: str  # 如 CA, NY
    name: str
    
    def __post_init__(self):
        if len(self.code) != 2:
            raise ValueError("State code must be 2 characters")
        if not self.code.isupper():
            raise ValueError("State code must be uppercase")
    
    def __str__(self):
        return f"{self.code} ({self.name})"


@dataclass(frozen=True)
class StreetAddress:
    """值对象：街道地址"""
    line1: str
    line2: str = ""  # 可选的第二行
    
    def __post_init__(self):
        if not self.line1 or len(self.line1.strip()) == 0:
            raise ValueError("Street address line 1 cannot be empty")
    
    def __str__(self):
        if self.line2:
            return f"{self.line1}, {self.line2}"
        return self.line1


@dataclass(frozen=True)
class Address:
    """值对象：完整地址
    
    由多个更小的值对象组合而成
    """
    street: StreetAddress
    city: City
    state: State
    zip_code: ZipCode
    
    def format_single_line(self) -> str:
        """单行格式"""
        parts = [
            str(self.street),
            str(self.city),
            str(self.state.code),
            str(self.zip_code)
        ]
        return ", ".join(parts)
    
    def format_multi_line(self) -> str:
        """多行格式"""
        lines = [str(self.street)]
        city_state_zip = f"{self.city}, {self.state.code} {self.zip_code}"
        lines.append(city_state_zip)
        return "\n".join(lines)
    
    def __str__(self):
        return self.format_single_line()


# 使用示例
def address_example():
    """演示地址值对象的使用"""
    # 创建地址
    address = Address(
        street=StreetAddress("123 Main St", "Apt 4B"),
        city=City("Springfield"),
        state=State("IL", "Illinois"),
        zip_code=ZipCode("62701")
    )
    
    print("Single line:", address.format_single_line())
    print("\nMulti line:")
    print(address.format_multi_line())
    
    # 尝试创建无效地址（应该失败）
    try:
        invalid_address = Address(
            street=StreetAddress(""),  # 空街道地址
            city=City("Test"),
            state=State("CA", "California"),
            zip_code=ZipCode("12345")
        )
    except ValueError as e:
        print(f"\nValidation error: {e}")
    
    # 值对象相等性
    address2 = Address(
        street=StreetAddress("123 Main St", "Apt 4B"),
        city=City("Springfield"),
        state=State("IL", "Illinois"),
        zip_code=ZipCode("62701")
    )
    
    print(f"\nAddresses equal: {address == address2}")  # True


@dataclass(frozen=True)
class DateRange:
    """值对象：日期范围"""
    start_date: date
    end_date: date
    
    def __post_init__(self):
        if self.end_date < self.start_date:
            raise ValueError("End date cannot be before start date")
    
    def contains(self, d: date) -> bool:
        """判断日期是否在范围内"""
        return self.start_date <= d <= self.end_date
    
    def overlaps(self, other: 'DateRange') -> bool:
        """判断是否与另一个日期范围重叠"""
        return self.start_date <= other.end_date and other.start_date <= self.end_date
    
    def duration_days(self) -> int:
        """计算天数"""
        return (self.end_date - self.start_date).days
    
    def __str__(self):
        return f"{self.start_date} to {self.end_date}"

/**
 * 纬度值对象
 */
public final class Latitude {
    private final double value;
    
    public Latitude(double value) {
        if (value < -90 || value > 90) {
            throw new IllegalArgumentException("Latitude must be between -90 and 90");
        }
        this.value = value;
    }
    
    public double getValue() { return value; }
    
    public boolean isNorthern() {
        return value > 0;
    }
    
    public boolean isSouthern() {
        return value < 0;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Latitude latitude = (Latitude) o;
        return Double.compare(value, latitude.value) == 0;
    }
    
    @Override
    public int hashCode() {
        return Double.hashCode(value);
    }
}

/**
 * 经度值对象
 */
public final class Longitude {
    private final double value;
    
    public Longitude(double value) {
        if (value < -180 || value > 180) {
            throw new IllegalArgumentException("Longitude must be between -180 and 180");
        }
        this.value = value;
    }
    
    public double getValue() { return value; }
    
    public boolean isEastern() {
        return value > 0;
    }
    
    public boolean isWestern() {
        return value < 0;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Longitude longitude = (Longitude) o;
        return Double.compare(value, longitude.value) == 0;
    }
    
    @Override
    public int hashCode() {
        return Double.hashCode(value);
    }
}

/**
 * 地理坐标值对象
 * 由纬度和经度组合而成
 */
public final class GeoCoordinate {
    private final Latitude latitude;
    private final Longitude longitude;
    
    public GeoCoordinate(Latitude latitude, Longitude longitude) {
        this.latitude = latitude;
        this.longitude = longitude;
    }
    
    public GeoCoordinate(double lat, double lon) {
        this(new Latitude(lat), new Longitude(lon));
    }
    
    /**
     * 计算与另一个坐标的距离（Haversine 公式）
     */
    public double distanceTo(GeoCoordinate other) {
        double earthRadiusKm = 6371.0;
        
        double lat1Rad = Math.toRadians(this.latitude.getValue());
        double lat2Rad = Math.toRadians(other.latitude.getValue());
        double deltaLatRad = Math.toRadians(other.latitude.getValue() - this.latitude.getValue());
        double deltaLonRad = Math.toRadians(other.longitude.getValue() - this.longitude.getValue());
        
        double a = Math.sin(deltaLatRad / 2) * Math.sin(deltaLatRad / 2) +
                   Math.cos(lat1Rad) * Math.cos(lat2Rad) *
                   Math.sin(deltaLonRad / 2) * Math.sin(deltaLonRad / 2);
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        
        return earthRadiusKm * c;
    }
    
    public Latitude getLatitude() { return latitude; }
    public Longitude getLongitude() { return longitude; }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        GeoCoordinate that = (GeoCoordinate) o;
        return latitude.equals(that.latitude) && longitude.equals(that.longitude);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(latitude, longitude);
    }
    
    @Override
    public String toString() {
        return String.format("(%.6f, %.6f)", latitude.getValue(), longitude.getValue());
    }
}

public class Money {
    private double amount;
    private String currency;
    
    public void setAmount(double amount) {
        this.amount = amount;
    }
    
    public void setCurrency(String currency) {
        this.currency = currency;
    }
}