Java语言的七块地基：从面向对象到可靠的资源释放（001–007）

业务变化
   │
   ▼
抽象 ──► 接口/抽象类 ──► 多态调用
   │                           │
   │                           ▼
   └────► 封装对象状态     重载与重写
                │              │
                ▼              ▼
          equals/hashCode   参数如何传递
                │              │
                └──────┬───────┘
                       ▼
              不可变值与资源边界
                String / final / finally

public class Account {
    private BigDecimal balance;

    public void setBalance(BigDecimal balance) {
        this.balance = balance;
    }
}

public final class Account {
    private BigDecimal balance;

    public Account(BigDecimal openingBalance) {
        requireNonNegative(openingBalance);
        this.balance = openingBalance;
    }

    public void debit(BigDecimal amount) {
        requirePositive(amount);
        if (balance.compareTo(amount) < 0) {
            throw new IllegalStateException("余额不足");
        }
        balance = balance.subtract(amount);
    }

    public BigDecimal balance() {
        return balance;
    }

    private static void requirePositive(BigDecimal value) {
        if (value == null || value.signum() <= 0) {
            throw new IllegalArgumentException("金额必须大于 0");
        }
    }

    private static void requireNonNegative(BigDecimal value) {
        if (value == null || value.signum() < 0) {
            throw new IllegalArgumentException("余额不能为负数");
        }
    }
}

public interface PaymentChannel {
    PaymentResult pay(PaymentCommand command);
}

public abstract class AbstractPaymentChannel implements PaymentChannel {
    @Override
    public final PaymentResult pay(PaymentCommand command) {
        validate(command);
        String requestId = createRequestId();
        return doPay(requestId, command);
    }

    protected void validate(PaymentCommand command) {
        // 通用校验
    }

    protected abstract PaymentResult doPay(
            String requestId, PaymentCommand command);

    private String createRequestId() {
        return UUID.randomUUID().toString();
    }
}

不推荐：OrderService extends AlipayChannel

推荐：  OrderService ──has-a──► PaymentChannel
                                  ▲
                     ┌────────────┴────────────┐
                  AlipayChannel           CardChannel

PaymentChannel channel = route(command.channelCode());
PaymentResult result = channel.pay(command);

class Payment {
    String describe(Object value) {
        return "Payment:Object";
    }

    String describe(String value) {
        return "Payment:String";
    }
}

class CardPayment extends Payment {
    @Override
    String describe(String value) {
        return "CardPayment:String";
    }
}

Payment payment = new CardPayment();
Object value = "100";
System.out.println(payment.describe(value));

Payment:Object

第 1 步：编译器看声明类型
payment 是 Payment，value 是 Object
        └─► 选定签名 describe(Object)

第 2 步：JVM 看实际接收者
实际对象是 CardPayment
        └─► 查找是否重写了 describe(Object)
            没有，所以执行 Payment.describe(Object)

void send(String value) {}
void send(Integer value) {}

// send(null); // 编译错误：String 和 Integer 互不为父子类型

public interface Refundable {
    RefundResult refund(RefundCommand command);
}

public abstract class AbstractRefundChannel implements Refundable {
    private final Clock clock;

    protected AbstractRefundChannel(Clock clock) {
        this.clock = clock;
    }

    @Override
    public final RefundResult refund(RefundCommand command) {
        checkDeadline(command, clock.instant());
        return doRefund(command);
    }

    protected abstract RefundResult doRefund(RefundCommand command);
}

调用方 ──依赖──► PaymentChannel（接口，稳定契约）
                         ▲
                         │ implements
              AbstractPaymentChannel（抽象类，共同骨架）
                         ▲
                 ┌───────┴───────┐
              Alipay           Card

调用前：
main.account ───────────────► Account{balance=100}

调用 debit(account) 时：复制引用值
main.account ───────┐
                    ├────────► 同一个 Account 对象
debit.parameter ────┘

所以：通过 parameter 修改对象，main 能看到；
但：把 parameter 改指向另一个对象，不会改变 main.account。

static void changeNumber(int value) {
    value = 99;
}

static void changeAccount(Account account) {
    account.debit(new BigDecimal("10"));
}

static void replaceAccount(Account account) {
    account = new Account(new BigDecimal("999"));
}

int number = 1;
Account account = new Account(new BigDecimal("100"));

changeNumber(number);       // number 仍是 1
changeAccount(account);     // 原对象余额变成 90
replaceAccount(account);    // account 仍指向余额为 90 的原对象

static void swap(Object left, Object right) {
    Object temp = left;
    left = right;
    right = temp;
}

record Money(BigDecimal amount, Currency currency) {
    Money add(Money other) {
        checkSameCurrency(other);
        return new Money(amount.add(other.amount), currency);
    }
}

key
 │
 ├─► hashCode() ─► 扰动 ─► 定位桶下标
 │                              │
 │                              ▼
 └──────────────────────► 在桶内用 equals() 确认

public final class OrderId {
    private final String value;

    public OrderId(String value) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException("订单号不能为空");
        }
        this.value = value;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof OrderId that)) return false;
        return value.equals(that.value);
    }

    @Override
    public int hashCode() {
        return value.hashCode();
    }
}

public record OrderId(String value) {
    public OrderId {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException("订单号不能为空");
        }
    }
}

Map<UserKey, String> map = new HashMap<>();
UserKey key = new UserKey("alice");
map.put(key, "data");

key.setName("bob");
System.out.println(map.get(key)); // 可能得到 null

String original = "pay";
String upper = original.toUpperCase();

System.out.println(original); // pay
System.out.println(upper);    // PAY

堆内存
┌──────────────────────────────────────┐
│ 字符串常量池                          │
│   "pay" ◄──── a                      │
│      ▲                                │
│      └──── b = new String("pay").intern()
│                                      │
│ 普通堆对象                            │
│   new String("pay") ◄──── b（intern 前）
└──────────────────────────────────────┘

String a = "pay";
String b = new String("pay");

System.out.println(a == b);      // false，引用不同
System.out.println(a.equals(b)); // true，内容相同
System.out.println(a == b.intern()); // true，取得池中规范引用

String a = "pay" + "ment"; // 通常直接成为常量 "payment"

StringBuilder builder = new StringBuilder();
for (String item : items) {
    builder.append(item).append(',');
}
String result = builder.toString();

final int timeout = 1000;             // 变量只能赋值一次
final PaymentChannel channel = route(); // 引用不能改指向
                                       // 但对象未必不可变

class Parent {
    final void validate() {}           // 子类不能重写
}

final class OrderId {}                 // 类不能被继承

try {
    process();
} finally {
    release();
}

try (InputStream in = Files.newInputStream(path);
     BufferedInputStream buffered = new BufferedInputStream(in)) {
    return buffered.readAllBytes();
}

申请资源 A ─► 申请资源 B ─► 执行业务
                              │
                  ┌───────────┴───────────┐
                  ▼                       ▼
                成功                    抛异常
                  │                       │
                  └────► 关闭 B ─► 关闭 A ┘
                         （逆序）

public final class NativeBuffer implements AutoCloseable {
    private static final Cleaner CLEANER = Cleaner.create();

    private static final class State implements Runnable {
        private long address;

        State(long address) {
            this.address = address;
        }

        @Override
        public void run() {
            if (address != 0) {
                freeNativeMemory(address);
                address = 0;
            }
        }
    }

    private final State state;
    private final Cleaner.Cleanable cleanable;

    NativeBuffer(long address) {
        this.state = new State(address);
        this.cleanable = CLEANER.register(this, state);
    }

    @Override
    public void close() {
        cleanable.clean(); // 显式、幂等地清理
    }
}

PaymentCommand（不可变命令）
  ├─ final 字段 / record
  ├─ String 渠道码不可变
  └─ 参数按值传递，服务不会替换调用方变量
                 │
                 ▼
PaymentChannel（接口：能力契约）
                 ▲
AbstractPaymentChannel（抽象类：校验和审计骨架）
                 ▲
        ┌────────┴────────┐
     AlipayChannel     CardChannel   ← 重写产生运行时多态
        │
        └─ SDK 方法可重载，但签名在编译期确定

OrderId / RequestId（值对象）
  └─ equals + hashCode 一致，安全用作 Map Key

外部连接 / 文件 / Native 资源
  └─ AutoCloseable + try-with-resources，Cleaner 只兜底