// ===== 面向过程：数据与行为分离 =====
class ProcedureStyle {
    // 账户数据：只是一堆松散的变量，谁都能改
    static String[] ids = {"A001", "A002"};
    static long[] balances = {1000_00L, 500_00L}; // 单位：分

    // 转账逻辑写在外部函数里，靠下标操作数据
    static void transfer(int from, int to, long amount) {
        if (balances[from] < amount) {
            throw new IllegalStateException("余额不足");
        }
        balances[from] -= amount;
        balances[to] += amount;
    }

    public static void main(String[] args) {
        transfer(0, 1, 200_00L);
        System.out.println(balances[0]); // 80000
    }
}

// ===== 面向对象：数据与行为绑定 =====
class Account {
    private final String id;   // 数据私有，外部拿不到
    private long balance;      // 单位：分，用 long 避免浮点误差

    public Account(String id, long balance) {
        this.id = id;
        this.balance = balance;
    }

    // 行为归属于 Account 自己：它才知道什么叫做"合法扣款"
    public void transferTo(Account target, long amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("金额必须为正");
        }
        if (this.balance < amount) {
            throw new IllegalStateException("余额不足");
        }
        this.balance -= amount;
        target.deposit(amount); // 对象之间发消息
    }

    private void deposit(long amount) {
        this.balance += amount;
    }

    public long getBalance() {
        return balance;
    }
}

public class ClassMembers {
    // 1. 实例字段：每个对象一份，随对象分配在堆上
    private String name;
    // 2. 静态字段：全类一份，JDK 8 起存放在堆中的 Class 对象末尾（即元空间之外的堆）
    private static int count;

    // 3. 实例初始化块：编译后被拷贝进每个 <init> 的开头（super() 之后）
    {
        System.out.println("实例初始化块执行");
        name = "默认名称";
    }

    // 4. 静态初始化块：编译后合并进 <clinit>，类加载的初始化阶段执行且仅执行一次
    static {
        System.out.println("静态初始化块执行");
        count = 0;
    }

    // 5. 构造器：编译成 <init> 方法
    public ClassMembers() {
        this.name = "构造器中赋值";
    }

    // 6. 方法：编译进方法表，非 private 实例方法参与虚方法分派
    public void sayHello() {
        System.out.println("Hello, " + name);
    }

    // 7. 静态成员内部类：不持有外部类引用
    public static class StaticInner {
        void show() {
            // 可以访问外部类的静态成员
            System.out.println("count = " + count);
        }
    }

    // 8. 非静态内部类：编译后隐式持有外部类 this 引用（this$0），可能导致内存泄漏
    public class Inner {
        void show() {
            System.out.println("name = " + name); // 直接访问外部实例字段
        }
    }
}

public class ObjectCreation {
    private int value = 10;

    public ObjectCreation(int value) {
        this.value = value;
    }

    public static void main(String[] args) {
        ObjectCreation obj = new ObjectCreation(20);
        System.out.println(obj.value);
    }
}

// javap -c -p ObjectCreation.class 的关键输出（已加注释说明）
// main 方法：
//  0: new           #7   // class ObjectCreation
//      ① 在堆中分配内存，字段全部置零值（value = 0），返回引用压栈
//  3: dup                // 复制栈顶引用，一份给 invokespecial 消费，一份留给后续使用
//  4: ldc           #9   // 把 int 常量 20 压栈
//  6: invokespecial #11  // Method "<init>":(I)V
//      ② 调用构造器完成初始化：先调父类 <init>，再执行实例块与字段赋值，再执行构造器体
//  9: astore_1           // ③ 把引用存入局部变量表槽位 1（obj）
// 10: getstatic     #13  // ④ 后续通过引用访问字段

// <init> 方法：
//  0: aload_0
//  1: invokespecial #1   // Method java/lang/Object."<init>":()V  —— 父类构造器必须先执行
//  4: aload_0
//  5: bipush        10   // 字段的显式初始值在此处赋值
//  7: putfield      #7   // Field value:I
// 10: aload_0
// 11: iload_1            // 构造器参数
// 12: putfield      #7   // Field value:I  —— 构造器体覆盖初始值
// 15: return

public class ThisDemo {
    private final String name;
    private int age;
    private String remark;

    public ThisDemo(String name) {
        // this() 必须是构造器体的第一条语句，否则编译错误
        this(name, 0); // 复用下面的全参构造器
    }

    public ThisDemo(String name, int age) {
        this.name = name; // 左侧 this.name 指字段，右侧 name 指参数
        this.age = age;
    }

    // 链式 setter：返回 this 让调用方可以连续调用
    public ThisDemo remark(String remark) {
        this.remark = remark;
        return this;
    }

    // 把自身作为实参传递（事件回调注册场景常见）
    public void register() {
        EventBus.register(this);
    }

    @Override
    public String toString() {
        return "ThisDemo{name='" + name + "', age=" + age + ", remark='" + remark + "'}";
    }

    public static void main(String[] args) {
        ThisDemo d = new ThisDemo("张三").remark("VIP 客户");
        System.out.println(d);
    }
}

// 仅为让示例代码可编译而存在的桩类
class EventBus {
    static void register(Object listener) {
        System.out.println("注册监听器：" + listener.getClass().getSimpleName());
    }
}

public class StaticVsInstance {
    static class Parent {
        static String tag() { return "Parent"; }  // 静态方法：隐藏，不是重写
        String name() { return "Parent"; }        // 实例方法：重写
    }

    static class Child extends Parent {
        static String tag() { return "Child"; }
        @Override
        String name() { return "Child"; }
    }

    public static void main(String[] args) {
        Parent p = new Child();          // 向上转型
        System.out.println(p.name());    // Child —— 实例方法走虚分派
        System.out.println(p.tag());     // Parent —— 静态方法看编译期类型！
        System.out.println(((Child) p).tag()); // Child
    }
}

public class ReferenceCompare {
    public static void main(String[] args) {
        String s1 = new String("java");       // 强制在堆里新建对象
        String s2 = new String("java");       // 另一个堆对象
        String s3 = "java";                   // 指向字符串常量池中的同一对象
        String s4 = "java";

        System.out.println(s1 == s2);         // false：两个不同的堆对象
        System.out.println(s1.equals(s2));    // true：String 重写了 equals，逐字符比较内容
        System.out.println(s3 == s4);         // true：常量池复用
        System.out.println(s1 == s3);         // false：堆对象 vs 常量池对象
        System.out.println(s1.intern() == s3);// true：intern() 返回池中对象

        Integer i1 = 127, i2 = 127;           // 落在 IntegerCache [-128,127] 内
        Integer i3 = 128, i4 = 128;           // 超出缓存范围，各自 new
        System.out.println(i1 == i2);         // true：缓存命中，同一对象
        System.out.println(i3 == i4);         // false：不同对象
        System.out.println(i3.equals(i4));    // true：包装类重写了 equals 比较数值
    }
}

public class EncapsulationDemo {
    private String phone;
    private int age;

    public String getPhone() {
        // 对外只暴露脱敏后的手机号，原始值不外泄
        return phone == null ? null : phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }

    public void setPhone(String phone) {
        // 校验放在唯一入口，任何调用方都无法绕过
        if (phone != null && !phone.matches("^1[3-9]\\d{9}$")) {
            throw new IllegalArgumentException("手机号格式非法：" + phone);
        }
        this.phone = phone;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄超出合理范围：" + age);
        }
        this.age = age;
    }

    public static void main(String[] args) {
        EncapsulationDemo u = new EncapsulationDemo();
        u.setPhone("13812345678");
        u.setAge(28);
        System.out.println(u.getPhone()); // 138****5678
        u.setAge(-1); // 抛 IllegalArgumentException
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class ImmutableOrder { // ① 类 final，禁止继承破坏
    private final String orderNo;                 // ② 全部 private final
    private final List<String> items;             // 可变字段是最大风险点

    public ImmutableOrder(String orderNo, List<String> items) {
        this.orderNo = orderNo;
        // ③ 构造器防御性拷贝：外部后续修改 items 不影响本对象
        this.items = new ArrayList<>(items);
    }

    public String getOrderNo() {
        return orderNo;
    }

    public List<String> getItems() {
        // ④ getter 也做拷贝，或者返回不可修改视图（推荐后者，零拷贝）
        return Collections.unmodifiableList(items);
    }

    // ⑤ "修改"操作返回新对象，而非修改自身（函数式风格）
    public ImmutableOrder withItem(String item) {
        List<String> copy = new ArrayList<>(items);
        copy.add(item);
        return new ImmutableOrder(orderNo, copy);
    }

    @Override
    public String toString() {
        return "ImmutableOrder{orderNo='" + orderNo + "', items=" + items + "}";
    }

    public static void main(String[] args) {
        List<String> src = new ArrayList<>();
        src.add("Java 编程思想");
        ImmutableOrder o1 = new ImmutableOrder("NO001", src);
        src.add("深入理解 JVM");   // 外部修改原集合
        System.out.println(o1);    // items 仍只有一项，防御成功
        ImmutableOrder o2 = o1.withItem("Effective Java");
        System.out.println(o2);    // 新对象，o1 不受影响
    }
}

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void speak() {
        System.out.println(name + " 发出声音");
    }
}

class Dog extends Animal {
    private String breed;

    public Dog(String name, String breed) {
        super(name);        // ① super(...)：调用父类构造器，必须是第一条语句
        this.breed = breed;
    }

    @Override
    public void speak() {
        super.speak();      // ② super.method()：调用被重写的父类方法（编译为 invokespecial）
        System.out.println(name + "：汪汪！品种 " + breed);
    }

    public void printName() {
        System.out.println(super.name); // ③ super.field：访问被隐藏的父类字段（很少用）
    }
}

public class SuperDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("小黑", "拉布拉多");
        dog.speak();     // 先输出父类版本，再输出子类版本
        dog.printName(); // 小黑
    }
}

import java.io.IOException;
import java.sql.SQLException;

class Repository {
    // 返回值是 Object，抛出 IOException
    public Object find(long id) throws IOException {
        return "entity-" + id;
    }

    void internalHook() {
        System.out.println("父类包私有钩子");
    }
}

class UserRepository extends Repository {
    // ① 返回值协变：Object → String（String 是 Object 的子类），合法
    // ② 异常收窄：IOException → SQLException（SQLException 是 Exception 子类，
    //    但此处父类抛的是 IOException，SQLException 并非其子类，故改为抛 IOException 子类演示）
    @Override
    public String find(long id) throws java.io.FileNotFoundException {
        // FileNotFoundException 是 IOException 的子类：异常变窄，合法
        return "user-" + id;
    }

    // ③ 访问权限变宽：包私有 → public，合法
    @Override
    public void internalHook() {
        System.out.println("子类增强了钩子，权限变宽");
    }

    // 下面两种写法如果取消注释会编译报错：
    // @Override protected Object find2() throws SQLException { } // 异常变宽（若父类为 IOException）
    // @Override private void internalHook2() { }                // 权限变窄
}

public class OverrideRuleDemo {
    public static void main(String[] args) {
        Repository repo = new UserRepository();
        try {
            String s = (String) repo.find(1L); // 编译类型是 Object，需强转
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class OverloadTrap {
    static void print(Integer i) { System.out.println("Integer"); }
    static void print(long l)    { System.out.println("long"); }
    static void print(Object o)  { System.out.println("Object"); }
    static void print(int... arr){ System.out.println("varargs"); }

    public static void main(String[] args) {
        print(10);      // 输出 long：不装箱优先，int 可以加宽转换为 long
        // print(Integer) 需要装箱，print(long) 只需加宽，加宽优先级高于装箱
        print(10L);     // long：精确匹配
        print("abc");   // Object：字符串只能匹配 Object
        print(1, 2);    // varargs：没有其它候选
    }
}

class Base {
    String name = "Base";
    int value = 1;

    String getName() { return name; } // 方法走多态
}

class Derived extends Base {
    String name = "Derived"; // 字段隐藏：Base.name 依然存在
    int value = 2;
}

public class FieldHidingDemo {
    public static void main(String[] args) {
        Base b = new Derived();
        System.out.println(b.name);       // Base —— 字段看编译期类型
        System.out.println(b.getName());  // Base —— 方法在 Derived 中没重写，执行的仍是 Base.getName()，
                                          // 而 Base.getName() 里的 name 解析到 Base.name
        Derived d = (Derived) b;
        System.out.println(d.name);       // Derived
        System.out.println(((Base) d).value); // 1
        System.out.println(d.value);      // 2
    }
}

class InitBase {
    static { System.out.println("1. 父类静态块"); }
    { System.out.println("4. 父类实例块"); }
    private String f = fieldInit("5. 父类字段赋值");

    static String fieldInit(String msg) {
        System.out.println(msg);
        return msg;
    }

    public InitBase() {
        System.out.println("6. 父类构造器体");
    }
}

class InitChild extends InitBase {
    static { System.out.println("2. 子类静态块"); }
    { System.out.println("7. 子类实例块"); }
    private String f2 = InitBase.fieldInit("8. 子类字段赋值");

    public InitChild() {
        System.out.println("9. 子类构造器体");
    }
}

public class InitOrderDemo {
    public static void main(String[] args) {
        System.out.println("--- 第一次 new ---");
        new InitChild();
        System.out.println("--- 第二次 new ---");
        new InitChild(); // 静态部分不再执行
    }
}

class Shape {
    public double area() { return 0; }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    @Override public double area() { return Math.PI * r * r; }
}

class Rect extends Shape {
    private final double w, h;
    Rect(double w, double h) { this.w = w; this.h = h; }
    @Override public double area() { return w * h; }
}

public class PolymorphismDemo {
    // 这个方法只依赖 Shape 抽象，未来新增 Triangle 无需修改此处（开闭原则）
    static double totalArea(Shape[] shapes) {
        double sum = 0;
        for (Shape s : shapes) {
            sum += s.area(); // 编译期只知道是 Shape.area，运行期才确定具体版本
        }
        return sum;
    }

    public static void main(String[] args) {
        Shape[] arr = { new Circle(1), new Rect(2, 3), new Circle(2) };
        System.out.printf("总面积 = %.4f%n", totalArea(arr));
    }
}

import java.util.ArrayList;
import java.util.List;

// 形式一：继承 + 方法重写
abstract class Bird {
    abstract void fly();
}

class Sparrow extends Bird {
    @Override void fly() { System.out.println("麻雀低空飞行"); }
}

// 形式二：接口实现
interface Flyable {
    void fly();
}

class Eagle implements Flyable {
    @Override public void fly() { System.out.println("鹰在高空盘旋"); }
}

// 形式三：抽象类（既有抽象方法约束，又有可复用实现）
abstract class AbstractBird implements Flyable {
    protected String name;
    AbstractBird(String name) { this.name = name; }
    // 模板方法：固定流程，把变化点留给子类
    public final void dailyRoutine() {
        System.out.print(name + " 的日常：");
        fly();
    }
}

class Swallow extends AbstractBird {
    Swallow() { super("燕子"); }
    @Override public void fly() { System.out.println("燕子迁徙飞行"); }
}

public class PolymorphismForms {
    public static void main(String[] args) {
        List<Flyable> list = new ArrayList<>();
        list.add(new Eagle());
        list.add(new Swallow());
        // 同一条 fly() 消息，不同对象有不同行为
        for (Flyable f : list) {
            f.fly();
        }
        new Swallow().dailyRoutine();
    }
}

public class CastDemo {
    static void handle(Object obj) {
        // JDK 16+ 模式匹配：判断成功后 obj 在分支内自动视为 String 类型
        if (obj instanceof String s && s.length() > 3) {
            System.out.println("长度大于 3 的字符串：" + s.toUpperCase());
        } else if (obj instanceof Integer i) {
            System.out.println("整数：" + (i * 2));
        } else {
            System.out.println("其它类型：" + obj);
        }
    }

    // JDK 21+ 还支持 switch 模式匹配（作为扩展了解）
    static String describe(Object o) {
        return switch (o) {
            case Integer i when i > 100 -> "大整数 " + i;
            case Integer i -> "小整数 " + i;
            case String s -> "字符串 " + s;
            case null -> "空值";
            default -> "未知类型";
        };
    }

    public static void main(String[] args) {
        handle("hello");
        handle(42);
        Object obj = "abc";
        // 旧写法（JDK 8 兼容）
        if (obj instanceof String) {
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

class TrapBase {
    String tag = "base";            // 陷阱一：字段不参与多态
    static String who() { return "static-base"; } // 陷阱二：静态方法不参与多态

    public TrapBase() {
        System.out.println("构造器中调用可重写方法 →");
        showTag();                  // 陷阱三：构造器中调用可重写方法
    }

    void showTag() {
        System.out.println("  Base.showTag, tag=" + tag);
    }
}

class TrapChild extends TrapBase {
    String tag = "child";
    private final String state = initState(); // 实例字段初始化

    private String initState() {
        System.out.println("  子类字段初始化执行");
        return "ready";
    }

    static String who() { return "static-child"; }

    @Override
    void showTag() {
        // 父类构造期间执行到这里，子类字段 state 尚未赋值 → null
        System.out.println("  Child.showTag, tag=" + tag + ", state=" + state);
    }
}

public class PolymorphismTrap {
    public static void main(String[] args) {
        TrapBase b = new TrapChild();
        System.out.println("字段访问 tag = " + b.tag); // base：字段看编译期类型
        System.out.println("静态方法 who = " + b.who()); // static-base：静态看编译期类型
    }
}

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

class BadKey { // 只重写 equals，没重写 hashCode
    private final int id;
    BadKey(int id) { this.id = id; }
    @Override public boolean equals(Object o) {
        return o instanceof BadKey && ((BadKey) o).id == this.id;
    }
}

class GoodKey {
    private final int id;
    GoodKey(int id) { this.id = id; }
    @Override public boolean equals(Object o) {
        return o instanceof GoodKey && ((GoodKey) o).id == this.id;
    }
    @Override public int hashCode() {
        return Objects.hash(id); // 用与 equals 相同的字段计算
    }
}

public class HashCodeDemo {
    public static void main(String[] args) {
        Set<BadKey> bad = new HashSet<>();
        bad.add(new BadKey(1));
        bad.add(new BadKey(1));
        System.out.println("BadKey 集合大小 = " + bad.size());   // 2！逻辑相等却都存进去了

        Set<GoodKey> good = new HashSet<>();
        good.add(new GoodKey(1));
        good.add(new GoodKey(1));
        System.out.println("GoodKey 集合大小 = " + good.size()); // 1，符合预期
    }
}

import java.util.Objects;

public final class User {
    private final String email;   // 参与相等判断的字段
    private final String nickname;// 参与相等判断
    private int loginCount;       // 不参与：可变字段不应进入 equals/hashCode

    public User(String email, String nickname) {
        this.email = Objects.requireNonNull(email, "email 不能为空");
        this.nickname = nickname;
    }

    @Override
    public boolean equals(Object o) {
        // ① 自反性优化：同一引用直接返回 true
        if (this == o) return true;
        // ② 类型检查用 instanceof（final 类）或 getClass()（需要严格类型相等时）
        if (!(o instanceof User)) return false; // 同时覆盖了 null 判断
        User other = (User) o;
        // ③ 逐一比较关键字段，引用类型用 Objects.equals 防 NPE，浮点用 compare，数组用 Arrays.equals
        return Objects.equals(this.email, other.email)
            && Objects.equals(this.nickname, other.nickname);
    }

    @Override
    public int hashCode() {
        // ④ 使用与 equals 完全相同的字段，推荐 Objects.hash（内部等价于 Arrays.hashCode）
        return Objects.hash(email, nickname);
    }

    @Override
    public String toString() {
        // ⑤ toString 应包含所有关键字段，便于日志排查
        return "User{email='" + email + "', nickname='" + nickname + "', loginCount=" + loginCount + "}";
    }

    public void incrementLogin() { loginCount++; }
}

import java.util.ArrayList;
import java.util.List;

class Address implements Cloneable {
    String city;
    Address(String city) { this.city = city; }
    @Override protected Address clone() throws CloneNotSupportedException {
        return (Address) super.clone();
    }
}

class Person implements Cloneable {
    String name;
    Address address;              // 引用类型字段
    List<String> tags;

    Person(String name, Address address) {
        this.name = name;
        this.address = address;
        this.tags = new ArrayList<>();
    }

    // 浅拷贝：address 与 tags 仍与原对象共享
    @Override
    protected Person shallowClone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }

    // 深拷贝：递归拷贝所有可变引用字段
    public Person deepClone() throws CloneNotSupportedException {
        Person copy = (Person) super.clone();
        copy.address = this.address.clone();           // 引用字段独立拷贝
        copy.tags = new ArrayList<>(this.tags);        // 集合独立拷贝
        return copy;
    }

    // 更推荐的替代方案：拷贝构造器，不依赖 Cloneable，可以正确初始化 final 字段
    public Person(Person other) {
        this.name = other.name;
        this.address = new Address(other.address.city);
        this.tags = new ArrayList<>(other.tags);
    }
}

public class CloneDemo {
    public static void main(String[] args) throws Exception {
        Person p = new Person("李四", new Address("杭州"));
        p.tags.add("VIP");

        Person shallow = p.shallowClone();
        shallow.address.city = "北京";
        System.out.println("浅拷贝后原对象城市 = " + p.address.city); // 北京：被影响了！

        Person deep = p.deepClone();
        deep.address.city = "上海";
        System.out.println("深拷贝后原对象城市 = " + p.address.city); // 北京：不受影响
        System.out.println("深拷贝对象城市 = " + deep.address.city); // 上海
    }
}

import java.util.ArrayList;
import java.util.List;

abstract class Animal {
    protected final String name;
    protected Animal(String name) { this.name = name; }

    // 抽象方法：子类必须给出实现，即"契约"
    public abstract void makeSound();

    // 模板方法：固定流程 + 可变点，用 final 防止子类破坏骨架
    public final void perform() {
        System.out.print("【表演开始】");
        makeSound();              // 多态发生地
        System.out.println("【表演结束】");
    }
}

class Cat extends Animal {
    Cat() { super("猫"); }
    @Override public void makeSound() { System.out.printf("%s：喵喵喵%n", name); }
}

class Dog2 extends Animal {
    Dog2() { super("狗"); }
    @Override public void makeSound() { System.out.printf("%s：汪汪汪%n", name); }
}

class Duck extends Animal {
    Duck() { super("鸭子"); }
    @Override public void makeSound() { System.out.printf("%s：嘎嘎嘎%n", name); }
}

class Keeper {
    // 只依赖 Animal 抽象：未来新增 Tiger、Lion，这里一行都不用改（开闭原则）
    public void inspect(List<Animal> animals) {
        for (Animal a : animals) {
            a.perform();
        }
    }
}

public class ZooDemo {
    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        animals.add(new Cat());
        animals.add(new Dog2());
        animals.add(new Duck());
        new Keeper().inspect(animals);
    }
}

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

// 抽象：支付能力契约
interface Payment {
    String channel();                                  // 渠道标识
    boolean supports(BigDecimal amount);               // 前置校验：单笔限额
    void pay(String orderNo, BigDecimal amount);       // 支付行为
}

class AliPay implements Payment {
    @Override public String channel() { return "ALIPAY"; }
    @Override public boolean supports(BigDecimal amount) {
        return amount.compareTo(new BigDecimal("50000")) <= 0;
    }
    @Override public void pay(String orderNo, BigDecimal amount) {
        System.out.printf("[支付宝] 订单 %s 扣款 %s 元%n", orderNo, amount);
    }
}

class WeChatPay implements Payment {
    @Override public String channel() { return "WECHAT"; }
    @Override public boolean supports(BigDecimal amount) {
        return amount.compareTo(new BigDecimal("20000")) <= 0;
    }
    @Override public void pay(String orderNo, BigDecimal amount) {
        System.out.printf("[微信] 订单 %s 扣款 %s 元%n", orderNo, amount);
    }
}

class BankCardPay implements Payment {
    @Override public String channel() { return "BANK"; }
    @Override public boolean supports(BigDecimal amount) {
        return amount.compareTo(new BigDecimal("1000000")) <= 0;
    }
    @Override public void pay(String orderNo, BigDecimal amount) {
        System.out.printf("[银行卡] 订单 %s 扣款 %s 元%n", orderNo, amount);
    }
}

// 高层模块依赖抽象（依赖倒置）：它不知道具体有几种支付方式
class OrderService {
    private final Map<String, Payment> channels = new HashMap<>();

    public void register(Payment p) {           // 扩展点：新增渠道只需注册
        channels.put(p.channel(), p);
    }

    public void settle(String orderNo, String channelCode, BigDecimal amount) {
        Payment p = channels.get(channelCode);
        if (p == null) {
            throw new IllegalArgumentException("不支持的支付渠道：" + channelCode);
        }
        if (!p.supports(amount)) {              // 多态：各渠道自己的限额规则
            throw new IllegalStateException("超出渠道限额：" + channelCode);
        }
        p.pay(orderNo, amount);                 // 多态：无 if-else
    }
}

public class OrderDemo {
    public static void main(String[] args) {
        OrderService service = new OrderService();
        service.register(new AliPay());
        service.register(new WeChatPay());
        service.register(new BankCardPay());

        service.settle("NO20260001", "ALIPAY", new BigDecimal("199.00"));
        service.settle("NO20260002", "WECHAT", new BigDecimal("88.50"));
        service.settle("NO20260003", "BANK", new BigDecimal("500000"));
        // 未来接入数字人民币：新增 DigitalRmbPay implements Payment 并 register，
        // OrderService 与 Payment 接口均无需修改 —— 这就是开闭原则的落地
    }
}