001｜面向对象四大特性：封装、继承、多态、抽象的边界与实际应用

// ❌ 这不是封装，这只是语法糖包装
public class BankAccount {
    private BigDecimal balance;  // 字段是 private 的

    public BigDecimal getBalance() { return balance; }  // 但我原样暴露了
    public void setBalance(BigDecimal b) { this.balance = b; }  // 外部可以任意修改
}
// 外部代码可以 balance.setBalance(balance.getBalance().subtract(amount))
// 这跟把 balance 设成 public 有区别吗？几乎没有。

// ✅ 这才是封装：隐藏内部状态，暴露有意义的行为
public class BankAccount {
    private BigDecimal balance;       // 内部状态不可见
    private List<Transaction> history; // 同样是内部状态

    public void deposit(BigDecimal amount) {
        if (amount.compareTo(BigDecimal.ZERO) <= 0)
            throw new IllegalArgumentException("存款金额必须大于0");
        balance = balance.add(amount);
        history.add(new Transaction("DEPOSIT", amount));
    }

    public void withdraw(BigDecimal amount) {
        if (amount.compareTo(balance) > 0)
            throw new InsufficientFundsException("余额不足");
        balance = balance.subtract(amount);
        history.add(new Transaction("WITHDRAW", amount));
    }

    public BigDecimal getBalance() { return balance; }  // 只读暴露是合理的
    // 注意：没有 setBalance！外部不能直接修改余额
}

// ❌ 返回了可变内部对象的引用，封装被破坏
public class Order {
    private List<OrderItem> items = new ArrayList<>();

    public List<OrderItem> getItems() {
        return items;  // 外部可以直接 items.clear()！封装形同虚设
    }
}
// 外部代码：
order.getItems().clear();  // 绕过了 Order 的所有业务规则

public List<OrderItem> getItems() {
    return Collections.unmodifiableList(items);  // 只读视图
}
// 或者如果外部需要的是独立副本：
public List<OrderItem> getItems() {
    return items.stream().map(OrderItem::copy).toList();
}

// 测试友好的封装设计
public class PricingEngine {
    private final DiscountStrategy discountStrategy;  // 通过构造注入

    public PricingEngine(DiscountStrategy strategy) {
        this.discountStrategy = strategy;
    }

    BigDecimal calculate(Order order) {  // 包级可见，测试可访问
        BigDecimal subtotal = order.getSubtotal();
        return discountStrategy.apply(subtotal);
    }
}

abstract class PaymentProcessor {
    public PaymentResult process(PaymentRequest request) {
        validateRequest(request);           // 所有子类共用
        Transaction tx = createTransaction(request);
        PaymentResult result = doPay(tx);   // 子类各自实现
        notifyUser(result);                 // 所有子类共用
        return result;
    }

    private void validateRequest(PaymentRequest req) { /* 通用校验 */ }
    private void notifyUser(PaymentResult result) { /* 通用通知 */ }
    protected abstract PaymentResult doPay(Transaction tx); // 留给子类
}

class AlipayProcessor extends PaymentProcessor { /* 实现 doPay */ }
class WechatPayProcessor extends PaymentProcessor { /* 实现 doPay */ }

// ❌ Stack 不是 Vector，它不应该暴露 insertElementAt()
public class Stack<E> extends Vector<E> {
    public E push(E item) { addElement(item); return item; }
    public E pop() { /* ... */ }
}
// 你可以这样用 Stack：stack.insertElementAt(x, 0) 
// 这彻底破坏了栈的 LIFO 语义！

// ✅ 组合：Stack 持有一个 List，只暴露栈操作
public class Stack<E> {
    private final List<E> elements = new ArrayList<>();

    public void push(E item) { elements.add(item); }
    public E pop() {
        if (elements.isEmpty()) throw new EmptyStackException();
        return elements.remove(elements.size() - 1);
    }
    // 没有 insert、remove(index) 等方法暴露
}

public class InstrumentedHashSet<E> extends HashSet<E> {
    private int addCount = 0;

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);  // HashSet.addAll 内部调用 this.add()！
    }

    public int getAddCount() { return addCount; }
}
// addAll(Arrays.asList("a", "b", "c")) → addCount = 6 而不是 3

// 重载 — 根据参数的编译期类型选择方法
public class Printer {
    public void print(String s)  { System.out.println("String: " + s); }
    public void print(Integer i) { System.out.println("Integer: " + i); }
    public void print(Object o)  { System.out.println("Object: " + o); }
}

Object obj = "hello";
printer.print(obj);  // 输出 "Object: hello" — 而不是 "String: hello"
// 因为重载方法的绑定发生在编译期，依据参数的声明类型（Object）而非实际类型（String）

// 重写 — 根据对象的实际运行时类型选择方法
interface Animal { void speak(); }
class Dog implements Animal { public void speak() { System.out.println("Woof"); } }
class Cat implements Animal { public void speak() { System.out.println("Meow"); } }

Animal a = new Dog();
a.speak();  // 输出 "Woof" — 运行时根据实际类型分派

a = new Cat();
a.speak();  // 输出 "Meow"

public class Dispatcher {
    void handle(Animal a) { System.out.println("Animal handler"); }
    void handle(Dog d)    { System.out.println("Dog handler"); }

    public static void main(String[ ] args) {

        Dispatcher d = new Dispatcher();
        Animal dog = new Dog();
        d.handle(dog);  // 输出什么？
    }
}
// 输出："Animal handler"
// handle() 是重载（静态分派），编译期 dog 的类型是 Animal，绑定到 handle(Animal)

if (animal.getClass() == Dog.class)
    // 直接内联 Dog.speak 的代码（或直接跳转）
else
    // 走虚方法表

// ❌ 没有利用多态——每增加一种支付方式就要修改 process 方法
public void process(String paymentType) {
    if ("alipay".equals(paymentType)) {
        // 支付宝逻辑
    } else if ("wechat".equals(paymentType)) {
        // 微信支付逻辑
    } else if ("unionpay".equals(paymentType)) {
        // 银联逻辑（新增：必须修改这个类）
    }
}

// ✅ 多态设计——增加新支付方式只需新增类，process 方法不用改
interface PaymentMethod { void pay(Order order); }
class Alipay implements PaymentMethod { /* ... */ }
class WechatPay implements PaymentMethod { /* ... */ }
class UnionPay implements PaymentMethod { /* ... */ }

public void process(PaymentMethod method, Order order) {
    method.pay(order);  // 一行替代了所有 if-else
}

// 认知抽象：从"狗"、"猫"、"鸟"中提取出"动物"这个概念
// 语言抽象：用 interface 表达这个概念
interface Animal {
    void move();   // 所有动物都会移动，但方式不同
    void eat();    // 所有动物都需要进食
    // 我们"忽略"了具体的移动方式和食谱——这就是抽象
}

class User implements Serializable, Comparable<User>, Cloneable {
    // User IS NOT A Serializable → User CAN BE serialized
    // User IS NOT A Comparable → User CAN BE compared
    // User IS NOT A Cloneable → User CAN BE cloned
}

abstract class BaseController {
    // 公共实现
    protected <T> Result<T> executeWithAudit(Supplier<T> action) {
        long start = System.currentTimeMillis();
        try {
            T result = action.get();
            auditLog("SUCCESS", System.currentTimeMillis() - start);
            return Result.ok(result);
        } catch (BusinessException e) {
            auditLog("BIZ_ERROR", System.currentTimeMillis() - start);
            return Result.fail(e.getCode(), e.getMessage());
        }
    }
    // 留给子类：不同业务需要不同的校验逻辑
    protected abstract void validate(Request req);
}

你需要在多个类之间共享实现吗？
├── 是 → 用抽象类（但要自问：能不能用组合 + 接口替代？）
└── 否 → 你想表达"能做"多种事情吗？
    ├── 是 → 用接口
    └── 否 → 你想建立严格的 IS-A 类型层次吗？
        ├── 是 → 用抽象类（仍可同时实现接口）
        └── 否 → 用具体类 + 接口

// ❌ 抽象层次太低：跟没抽象一样
interface OrderService {
    Order createOrder(Long userId, Long productId, Integer quantity, BigDecimal price);
    // 参数列表跟数据库字段一一对应，接口只是 DAO 的薄封装
}

// ❌ 抽象层次太高：完全不可用
interface DataProcessor<T, R, C extends ProcessingContext<? super T, ? extends R>> {
    ProcessingResult<R, C> process(DataRequest<T, C> request, ProcessingStrategy<T, R, C> strategy);
    // 谁能一眼看懂这个接口是干什么的？
}

// ✅ 合适的抽象层次
interface OrderService {
    OrderResult placeOrder(PlaceOrderCommand command);  // 意图明确：下单
    OrderQueryResult queryOrders(OrderQuery query);     // 意图明确：查单
    void cancelOrder(OrderId orderId, CancelReason reason);  // 意图明确：取消
}

// 1. 抽象：定义"可计算报酬"的概念
interface Compensable {
    BigDecimal calculateCompensation();  // 忽略具体计算公式
}

// 2. 封装：隐藏内部状态
class Employee {
    private final String id;
    private final BigDecimal baseSalary;
    private final int yearsOfService;

    // constructor, getters...
    // 注意：没有无意义的 setter
}

// 3. 继承：IS-A 关系成立
abstract class Engineer extends Employee implements Compensable {
    protected final List<Project> projects;

    // 4. 多态：子类各自实现报酬计算
}

class SeniorEngineer extends Engineer {
    private static final BigDecimal BONUS_RATE = new BigDecimal("0.2");

    @Override
    public BigDecimal calculateCompensation() {
        return baseSalary.add(baseSalary.multiply(BONUS_RATE))
                .add(projectBonus());
    }
}

class JuniorEngineer extends Engineer {
    @Override
    public BigDecimal calculateCompensation() {
        return baseSalary;  // 初级工程师暂时没有项目分成
    }
}

// 使用方只需要知道 Compensable 这个抽象
class PayrollService {
    BigDecimal computeTotalPayroll(List<Compensable> staff) {
        return staff.stream()
                .map(Compensable::calculateCompensation)  // 多态！
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

Integer a = 1000;
Integer b = 1000;
System.out.println(a == b);        // false — 不同对象，== 比较引用
System.out.println(a.equals(b));   // true  — equals 比较值

Integer c = 100;
Integer d = 100;
System.out.println(c == d);        // true  — 缓存池！Integer 缓存了 -128~127

interface Repository {
    // ✅ 合理的默认方法：基于接口已有的抽象方法实现便捷逻辑
    default Optional<Entity> findByIdOrEmpty(Long id) {
        return Optional.ofNullable(findById(id));
    }

    // ❌ 不合理的默认方法：把实现逻辑塞进接口，破坏了接口的契约语义
    default Entity findByIdOrThrow(Long id) {
        Entity e = findById(id);
        if (e == null) throw new NotFoundException("Entity not found: " + id);
        return e;
        // 问题：这个异常应该是什么类型？应该用哪个日志器？接口不应该做这些决定。
    }

    Entity findById(Long id);  // 真正的抽象方法
}

信息隐藏（设计原则）
    └── 封装（语言机制实现）
    └── 接口抽象（另一种实现方式）

// JDK 的设计失误
public class Properties extends Hashtable<Object, Object> {
    // Properties 的语义是 String → String 的配置映射
    public String getProperty(String key) {
        return (String) get(key);
    }
    // 但因为继承了 Hashtable...
}

Properties props = new Properties();
props.put("port", 8080);            // 存入的是 Integer 8080，不是 String！
String port = props.getProperty("port");  // ClassCastException! getProperty 强转 String

public class OverloadPriority {
    void foo(int x)        { System.out.println("int"); }
    void foo(Integer x)    { System.out.println("Integer"); }
    void foo(Object x)     { System.out.println("Object"); }
    void foo(int... x)     { System.out.println("varargs"); }


    public static void main(String[ ] args) {

        OverloadPriority op = new OverloadPriority();
        op.foo(1);  // 输出 "int" — 精确匹配优先
        // 如果没有 foo(int), 会依次尝试:
        // 1. 自动装箱 → foo(Integer)
        // 2. 父类 → foo(Object)
        // 3. 可变参数 → foo(int...)
    }
}

class Animal {}
class Dog extends Animal {}
class Handler {
    void handle(Animal a) { System.out.println("Animal handler"); }
    void handle(Dog d)   { System.out.println("Dog handler"); }
}
Handler h = new Handler();
Animal dog = new Dog();
h.handle(dog);  // ?

// 编译错误！类型擦除后签名相同
void process(List<String> list) {}
void process(List<Integer> list) {} // 编译失败: both methods have same erasure

interface A { default void greet() { System.out.println("A"); } }
interface B { default void greet() { System.out.println("B"); } }
class C implements A, B { }
// 编译错误！greet() 被 A 和 B 同时定义，C 必须覆盖
// class C implements A, B { public void greet() { A.super.greet(); } }

// 这是一个"有封装、继承、多态但没有有效抽象"的代码
abstract class Animal {
    private String name;  // 封装 ✓
    abstract void makeSound();  // 多态的基础 ✓
}
class Dog extends Animal {  // 继承 ✓
    void makeSound() { System.out.println("Woof"); }
}

// 但这个层次结构只支持 Dog 和 Cat——
// 加一个 Robot（会移动但不是动物）时，就会犹豫要不要继承 Animal。
// 这说明最初的抽象（Animal）没有抓住真正的本质（Movable? SoundMaking?）。
// 这里的"抽象"只是语法上的，不是设计上的——这是一个失败的抽象。

AbstractOrderProcessor
    ├── PhysicalGoodsOrderProcessor
    │   ├── DomesticPhysicalOrderProcessor
    │   └── InternationalPhysicalOrderProcessor
    ├── DigitalGoodsOrderProcessor
    └── ServiceOrderProcessor

// 1. 将正交维度拆分为独立的策略接口
interface OrderValidator { ValidationResult validate(Order order); }
interface PaymentProcessor { PaymentResult pay(Order order); }
interface ShippingStrategy { ShippingInfo ship(Order order); }
interface Notifier { void notify(Order order, OrderEvent event); }

// 2. 订单处理器变成薄薄的编排层
class OrderProcessor {
    private final OrderValidator validator;
    private final PaymentProcessor payment;
    private final ShippingStrategy shipping;
    private final Notifier notifier;

    // 构造注入，运行时组合
    public OrderResult process(Order order) {
        ValidationResult vr = validator.validate(order);
        if (!vr.isValid()) return Result.invalid(vr);

        PaymentResult pr = payment.pay(order);
        if (!pr.isSuccess()) return Result.paymentFailed(pr);

        ShippingInfo si = shipping.ship(order);
        notifier.notify(order, OrderEvent.SHIPPED);
        return Result.ok(si);
    }
}

// 3. 不同的订单类型 = 不同的策略组合，而不是不同的子类
OrderProcessor physicalOrderProcessor = new OrderProcessor(
    new PhysicalGoodsValidator(),
    new OnlinePaymentProcessor(),
    new ExpressShipping(),
    new SmsAndEmailNotifier()
);

OrderProcessor digitalOrderProcessor = new OrderProcessor(
    new NoOpValidator(),         // 数字商品不需要地址校验
    new OnlinePaymentProcessor(),
    new NoOpShipping(),          // 数字商品不需要物流
    new EmailOnlyNotifier()
);

// ====== 维度一：支付方式（变化的维度） ======
interface PayMode {
    void invoke(PayRequest request);  // 发起支付的具体交互方式
    PayResult query(String orderNo);  // 查询支付结果
    String getModeName();             // "扫码付" / "H5付"
}

class QrCodePay implements PayMode {
    public void invoke(PayRequest req) {
        // 生成二维码，返回给客户端展示
    }
    public PayResult query(String orderNo) {
        // 轮询或等待回调
    }
    public String getModeName() { return "扫码付"; }
}

class H5Pay implements PayMode {
    public void invoke(PayRequest req) {
        // 构造支付URL，跳转H5页面
    }
    public PayResult query(String orderNo) {
        // 通过redirect_url回调或主动查询
    }
    public String getModeName() { return "H5付"; }
}

// ====== 维度二：支付渠道（稳定的抽象） ======
abstract class PaymentChannel {
    private static final Map<String, PaymentChannel> REGISTRY = new ConcurrentHashMap<>();

    protected String channelId;   // "alipay" / "wechat" / "unionpay"
    protected PayMode payMode;    // 桥接：渠道不关心具体方式

    public PaymentChannel(String channelId, PayMode payMode) {
        this.channelId = channelId;
        this.payMode = payMode;
        REGISTRY.put(channelId + "_" + payMode.getModeName(), this);
    }

    // 模板方法：渠道定义流程骨架，支付方式填充交互细节
    public final PayResponse pay(PayRequest request) {
        // 1. 渠道通用：参数校验（子类可扩展）
        validateRequest(request);
        // 2. 渠道通用：创建订单
        String orderNo = createOrder(request);
        // 3. 委托给支付方式：H5 就跳转，扫码就生成二维码
        payMode.invoke(request.withOrderNo(orderNo));
        // 4. 返回渠道响应
        return buildResponse(orderNo);
    }

    protected abstract void validateRequest(PayRequest request);
    protected abstract String createOrder(PayRequest request);
    protected abstract PayResponse buildResponse(String orderNo);

    public static PaymentChannel of(String channelId, PayMode mode) {
        return REGISTRY.get(channelId + "_" + mode.getModeName());
    }
}

// ====== 具体渠道实现 ======
class AlipayChannel extends PaymentChannel {
    public AlipayChannel(PayMode mode) { super("alipay", mode); }

    protected void validateRequest(PayRequest req) {
        // 支付宝特有的参数校验：pid、签名方式等
    }
    protected String createOrder(PayRequest req) {
        // 调用支付宝统一下单 API（alipay.trade.create / alipay.trade.precreate）
    }
    protected PayResponse buildResponse(String orderNo) {
        // 封装支付宝的响应
    }
}

class WechatChannel extends PaymentChannel {
    public WechatChannel(PayMode mode) { super("wechat", mode); }

    protected void validateRequest(PayRequest req) {
        // 微信特有校验：appid、mch_id、签名等
    }
    protected String createOrder(PayRequest req) {
        // 调用微信统一下单 API
    }
    protected PayResponse buildResponse(String orderNo) {
        // 封装微信的响应
    }
}

// ====== 使用示例 ======
// 只需 3+2=5 个类，覆盖 3×2 种组合，新增维度 O(n) 而非 O(n×m)
PaymentChannel alipayQrPay = new AlipayChannel(new QrCodePay());
PaymentChannel alipayH5Pay  = new AlipayChannel(new H5Pay());
PaymentChannel wechatQrPay  = new WechatChannel(new QrCodePay());
// ... 银联同理

// 运行时组合：
PaymentChannel channel = PaymentChannel.of("alipay", new H5Pay());
channel.pay(request);

interface PayNotificationHandler {
    void onCallback(CallbackData data);       // H5 付回调
    PayResult pollUntilComplete(String orderNo, Duration timeout); // 扫码付轮询
}

class QrCodePay implements PayMode {
    private final PayNotificationHandler handler;
    // handler.pollUntilComplete() 封装了定时轮询逻辑
}
class H5Pay implements PayMode {
    private final PayNotificationHandler handler;
    // handler.onCallback() 由框架层的回调接口触发
}

class CombinedPaymentOrchestrator {
    List<PaymentChannel> channels;  // 多个渠道

    PayResponse pay(PayRequest request) {
        // 将 totalAmount 按比例拆分到各渠道
        // 使用分布式事务（TCC 或 Saga）保证多个渠道的一致性
        // 任一渠道失败需要补偿
    }
}

// 每个渠道声明自己支持哪些支付方式
interface PayModeSupport {
    Set<String> supportedModes(); // {"qr_code", "h5", "installment"}
}

// 渠道不再在构造时绑定支付方式，而是在运行时通过 SPI 发现
// ServiceLoader<PayModeFactory> 加载所有可用的支付方式
// 每个渠道的 supportedModes() 声明能力，运行时分派