Java 类进阶：让对象边界经得住变化

import java.math.BigDecimal;
import java.util.Objects;
 
public final class GiftCard {
    private final String number;
    private BigDecimal balance;
 
    public GiftCard(String number, BigDecimal openingBalance) {
        this.number = Objects.requireNonNull(number, "number");
        Objects.requireNonNull(openingBalance, "openingBalance");
        if (openingBalance.signum() < 0) {
            throw new IllegalArgumentException("初始余额不能为负数");
        }
        this.balance = openingBalance;
    }
 
    public void recharge(BigDecimal amount) {
        Objects.requireNonNull(amount, "amount");
        if (amount.signum() <= 0) {
            throw new IllegalArgumentException("充值金额必须为正数");
        }
        balance = balance.add(amount);
    }
 
    public String number() {
        return number;
    }
 
    public BigDecimal balance() {
        return balance;
    }
}

public final class Distance {
    private Distance() {
        // 工具类不需要实例
    }
 
    public static final double METERS_PER_KILOMETER = 1_000.0;
 
    public static double kilometersToMeters(double kilometers) {
        return kilometers * METERS_PER_KILOMETER;
    }
}

public class Visit {
    private String visitorName;
    private static int totalVisits;
 
    public Visit(String visitorName) {
        this.visitorName = visitorName;
        totalVisits++;
    }
 
    public static int totalVisits() {
        return totalVisits;
    }
 
    public String summary() {
        return visitorName + "，累计访问数=" + totalVisits;
    }
}

public final class RuntimeConfig {
    private static int step = mark("字段初始化", 1);
 
    static {
        step = mark("静态块", step + 1);
    }
 
    private static int mark(String label, int value) {
        System.out.println(label + " -> " + value);
        return value;
    }
 
    public static int step() {
        return step;
    }
}

public static final java.util.List<String> TAGS = new java.util.ArrayList<>();

import java.util.Objects;
 
final class Customer {
    private String name;
 
    Customer(String name) {
        this.name = Objects.requireNonNull(name, "name");
    }
 
    String name() {
        return name;
    }
 
    void renameTo(String name) {
        this.name = Objects.requireNonNull(name, "name");
    }
}
 
public class CustomerDemo {
    static void rename(Customer customer) {
        customer.renameTo("新名字");
    }
 
    static void replace(Customer customer) {
        customer = new Customer("另一个对象");
    }
 
    public static void main(String[] args) {
        Customer original = new Customer("小林");
 
        rename(original);
        System.out.println(original.name()); // 新名字
 
        replace(original);
        System.out.println(original.name()); // 仍是新名字
    }
}

static BigDecimal totalOf(Order order) { ... }      // 查询
static void applyDiscount(Order order) { ... }      // 命令
static Order discountedCopy(Order order) { ... }    // 转换

public Address address() { return address; }              // 暴露内部对象
public Address addressCopy() { return new Address(address); } // 返回副本
public Customer renameTo(String name) { ...; return this; }   // 返回当前对象

import java.util.Objects;
 
public void changeAddress(Address next) {
    this.address = new Address(
            Objects.requireNonNull(next, "next")
    );
}

import java.util.Objects;
 
public final class Label {
    private String text;
 
    public Label(String text) {
        this.text = Objects.requireNonNull(text, "text");
    }
}

public void validateWith(LabelPolicy policy) {
    Objects.requireNonNull(policy, "policy").validate(this);
}

import java.util.Objects;
 
public final class MessageBuilder {
    private final StringBuilder content = new StringBuilder();
 
    public MessageBuilder append(String part) {
        content.append(Objects.requireNonNull(part, "part"));
        return this;
    }
 
    public String build() {
        return content.toString();
    }
 
    public static void main(String[] args) {
        String message = new MessageBuilder()
                .append("订单")
                .append("已创建")
                .build();
 
        System.out.println(message);
    }
}

@Override
public String toString() {
    return "GiftCard{" +
            "number='" + mask(number) + '\'' +
            ", balance=" + balance +
            '}';
}

private static String mask(String number) {
    int visible = Math.min(4, number.length());
    return "****" + number.substring(number.length() - visible);
}

String first = new String("JAVA");
String second = new String("JAVA");
 
System.out.println(first == second);      // false：不同实例
System.out.println(first.equals(second)); // true：字符序列相同

import java.util.Locale;
import java.util.Objects;
 
public final class Sku {
    private final String code;
 
    public Sku(String code) {
        String normalized = Objects.requireNonNull(code, "code")
                .trim()
                .toUpperCase(Locale.ROOT);
        if (normalized.isEmpty()) {
            throw new IllegalArgumentException("商品编码不能为空");
        }
        this.code = normalized;
    }
 
    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Sku that)) {
            return false;
        }
        return code.equals(that.code);
    }
 
    @Override
    public int hashCode() {
        return code.hashCode();
    }
 
    @Override
    public String toString() {
        return code;
    }
}

Profile a = new Profile("小林", new Address("杭州"));
Profile b = a;
b.address().renameCity("上海");

public Profile(Profile other) {
    this.name = other.name;
    this.address = other.address;
}

public Profile(Profile other) {
    Objects.requireNonNull(other, "other");
    this.name = other.name;
    this.address = new Address(other.address);
}

Profile copy = new Profile(original);       // 复制构造器
Profile copy = Profile.copyOf(original);    // 静态工厂
Profile renamed = original.withName("阿青"); // 不可变对象返回变体

import java.util.ArrayList;
import java.util.List;
 
public final class Order {
    private final List<OrderLine> lines = new ArrayList<>();
 
    public void addLine(Product product, int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("数量必须为正数");
        }
        lines.add(new OrderLine(product, quantity));
    }
 
    public List<OrderLine> lines() {
        return List.copyOf(lines);
    }
}

public Playlist(List<Song> songs) {
    this.songs = new ArrayList<>(Objects.requireNonNull(songs, "songs"));
}

public enum OrderStatus {
    DRAFT("草稿", false),
    SUBMITTED("已提交", false),
    PAID("已支付", false),
    CANCELLED("已取消", true),
    COMPLETED("已完成", true);
 
    private final String label;
    private final boolean terminal;
 
    OrderStatus(String label, boolean terminal) {
        this.label = label;
        this.terminal = terminal;
    }
 
    public String label() {
        return label;
    }
 
    public boolean isTerminal() {
        return terminal;
    }
}

public enum FeePolicy {
    STANDARD {
        @Override
        public int feeFor(int cents) {
            return cents / 20;
        }
    },
    VIP {
        @Override
        public int feeFor(int cents) {
            return 0;
        }
    };
 
    public abstract int feeFor(int cents);
}

Node first = new Node();
Node second = new Node();
first.next = second;
second.next = first;
 
first = null;
second = null;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
 
public class FirstLineReader {
    public static String readFirstLine(Path path) throws IOException {
        try (BufferedReader reader = Files.newBufferedReader(path)) {
            return reader.readLine();
        }
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicLong;
 
public class AdvancedOrderDemo {
    public static void main(String[] args) {
        Order order = new Order()
                .add(new Sku(" java-101 "), 2)
                .add(new Sku("DB-20"), 1)
                .submit();
 
        System.out.println(order);
        System.out.println(order.lines());
    }
}
 
enum OrderStatus {
    DRAFT, SUBMITTED, CANCELLED
}
 
final class Sku {
    private final String code;
 
    Sku(String code) {
        this.code = Objects.requireNonNull(code, "code")
                .trim()
                .toUpperCase(Locale.ROOT);
        if (this.code.isEmpty()) {
            throw new IllegalArgumentException("商品编码不能为空");
        }
    }
 
    @Override
    public boolean equals(Object other) {
        return this == other
                || other instanceof Sku that && code.equals(that.code);
    }
 
    @Override
    public int hashCode() {
        return code.hashCode();
    }
 
    @Override
    public String toString() {
        return code;
    }
}
 
final class OrderLine {
    private final Sku sku;
    private final int quantity;
 
    OrderLine(Sku sku, int quantity) {
        this.sku = Objects.requireNonNull(sku, "sku");
        if (quantity <= 0) {
            throw new IllegalArgumentException("数量必须为正数");
        }
        this.quantity = quantity;
    }
 
    @Override
    public String toString() {
        return sku + " × " + quantity;
    }
}
 
final class Order {
    private static final AtomicLong NEXT_ID = new AtomicLong(1);
 
    private final long id = NEXT_ID.getAndIncrement();
    private final List<OrderLine> lines = new ArrayList<>();
    private OrderStatus status = OrderStatus.DRAFT;
 
    Order add(Sku sku, int quantity) {
        requireDraft();
        lines.add(new OrderLine(sku, quantity));
        return this;
    }
 
    Order submit() {
        requireDraft();
        if (lines.isEmpty()) {
            throw new IllegalStateException("空订单不能提交");
        }
        status = OrderStatus.SUBMITTED;
        return this;
    }
 
    List<OrderLine> lines() {
        return List.copyOf(lines);
    }
 
    private void requireDraft() {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("只有草稿订单可以修改");
        }
    }
 
    @Override
    public boolean equals(Object other) {
        return this == other
                || other instanceof Order that && id == that.id;
    }
 
    @Override
    public int hashCode() {
        return Long.hashCode(id);
    }
 
    @Override
    public String toString() {
        return "Order{id=" + id +
                ", status=" + status +
                ", lineCount=" + lines.size() + '}';
    }
}

static void check(boolean condition, String message) {
    if (!condition) {
        throw new AssertionError(message);
    }
}
 
static void equalityContract() {
    Sku x = new Sku("java-101");
    Sku y = new Sku(" JAVA-101 ");
    Sku z = new Sku("Java-101");
 
    check(x.equals(x), "应满足自反性");
    check(x.equals(y) && y.equals(x), "应满足对称性");
    check(x.equals(y) && y.equals(z) && x.equals(z), "应满足传递性");
    check(x.hashCode() == y.hashCode(), "相等对象必须有相同哈希码");
    check(!x.equals(null), "非空对象不等于 null");
}