// 抽象类：表达「图形」这个概念，面积计算必须由子类给出
public abstract class Shape {
    // 抽象类中可以有普通字段，这是与接口的重要区别之一
    protected String name;

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

    // 抽象方法：只有签名，没有方法体
    public abstract double area();

    // 抽象类中可以有已经实现的方法
    public void describe() {
        System.out.println(name + " 的面积是 " + area());
    }
}

class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        super("圆形");   // 子类构造必须先调用父类构造
        this.radius = radius;
    }

    // 必须实现父类的全部抽象方法，否则 Circle 也要声明为 abstract
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public abstract class AbstractDemo {
    private final int id;

    // 抽象类构造器：用于初始化父类持有的状态
    public AbstractDemo(int id) {
        this.id = id;
        System.out.println("父类构造器执行, id=" + id);
    }

    public int getId() {
        return id;
    }
}

// 订单处理骨架：校验 -> 扣库存 -> 支付 -> 通知，其中「支付」由子类实现
public abstract class AbstractOrderProcessor {

    // final 保证算法骨架不被子类重写，这是模板方法的关键
    public final void process(String orderId) {
        validate(orderId);
        deductStock(orderId);
        pay(orderId);          // 可变步骤：抽象方法
        if (needNotify()) {    // 可变步骤：钩子方法
            notifyUser(orderId);
        }
    }

    private void validate(String orderId) {
        if (orderId == null || orderId.isEmpty()) {
            throw new IllegalArgumentException("订单号非法");
        }
    }

    private void deductStock(String orderId) {
        System.out.println("扣减库存: " + orderId);
    }

    private void notifyUser(String orderId) {
        System.out.println("通知用户: " + orderId);
    }

    /** 抽象方法：必须由子类给出具体实现 */
    protected abstract void pay(String orderId);

    /** 钩子方法：子类可选覆盖，默认返回 true */
    protected boolean needNotify() {
        return true;
    }
}

// 支付宝支付实现
class AliPayProcessor extends AbstractOrderProcessor {
    @Override
    protected void pay(String orderId) {
        System.out.println("调用支付宝 SDK 支付: " + orderId);
    }
}

// 内部员工订单：改写钩子，不需要发通知
class InternalOrderProcessor extends AbstractOrderProcessor {
    @Override
    protected void pay(String orderId) {
        System.out.println("内部记账, 不走真实支付: " + orderId);
    }

    @Override
    protected boolean needNotify() {
        return false;
    }
}

// 支付能力接口：只描述「能做什么」，不持有实例状态
public interface Payable {
    // 字段默认 public static final，且必须在声明时赋值
    int MAX_RETRY = 3;

    // 方法默认 public abstract
    boolean pay(double amount);

    // 退款也是一个契约
    default boolean refund(double amount) {
        // 默认实现：走与支付相反的流程
        System.out.println("默认退款实现, 金额=" + amount);
        return true;
    }
}

class WeChatPay implements Payable {
    @Override
    public boolean pay(double amount) {
        System.out.println("微信支付 " + amount + " 元, 最大重试 " + MAX_RETRY);
        return true;
    }
}

public interface Loggable {
    void log(String msg);

    // default 方法：提供默认实现，实现类可自由选择是否覆盖
    default void logError(String msg) {
        log("[ERROR] " + msg);
    }

    default void logWithTime(String msg) {
        log(System.currentTimeMillis() + " " + msg);
    }

    // 接口静态方法：属于接口本身，不能被实现类继承，只能通过 Loggable.xxx() 调用
    static Loggable console() {
        return msg -> System.out.println(msg);
    }
}

class LoggableDemo {
    public static void main(String[] args) {
        Loggable logger = Loggable.console();   // 静态方法的正确调用方式
        logger.logError("磁盘空间不足");

        // 实现类只实现一个抽象方法即可，default 方法免费获得
        Loggable fileLogger = msg -> System.out.println("写入文件: " + msg);
        fileLogger.logWithTime("订单创建");
    }
}

public interface ReportGenerator {
    default String toJson(String data) {
        return wrap("json", data);
    }

    default String toXml(String data) {
        return wrap("xml", data);
    }

    // private 方法：只在接口内部复用，不对外暴露，实现类也无法重写
    private String wrap(String type, String data) {
        return "<" + type + ">" + data + "</" + type + ">";
    }

    // private static 方法：供 static 方法复用
    private static String now() {
        return java.time.LocalDateTime.now().toString();
    }

    static String header() {
        return "generated at " + now();
    }
}

interface Flyable {
    default String move() {
        return "用翅膀飞";
    }
}

interface Swimmable {
    default String move() {
        return "用鳍游";
    }
}

// 场景一：两个无关接口冲突 -> 编译错误，必须显式重写
class Duck implements Flyable, Swimmable {
    @Override
    public String move() {
        // 通过 接口名.super.方法名() 精确选择，也可以两个都不用而自己实现
        return Flyable.super.move() + " / " + Swimmable.super.move();
    }
}

// 场景二：子接口优先
interface Vehicle {
    default String move() {
        return "在路上跑";
    }
}

// Amphibious 继承 Vehicle 并重写，它是「更具体」的接口
interface Amphibious extends Vehicle {
    @Override
    default String move() {
        return "水陆两栖移动";
    }
}

// 无需重写：Amphibious 比 Vehicle 更具体，直接胜出
class AmphibiousCar implements Vehicle, Amphibious {
}

// 场景三：类优先
class Animal {
    public String move() {
        return "用腿跑";
    }
}

// 即使 Penguin 实现了 Flyable，Animal 的具体方法仍然胜出，default 被忽略
class Penguin extends Animal implements Flyable {
}

@FunctionalInterface
public interface OrderValidator {
    /** 唯一的抽象方法 */
    boolean validate(String orderId);

    // default 方法不计入抽象方法数量
    default OrderValidator and(OrderValidator other) {
        return id -> validate(id) && other.validate(id);
    }
}

class ValidatorDemo {
    public static void main(String[] args) {
        // Lambda 直接作为函数式接口的实现
        OrderValidator notEmpty = id -> id != null && !id.isEmpty();
        OrderValidator lengthOk = id -> id.length() >= 6;

        // 组合出新的校验器
        OrderValidator combined = notEmpty.and(lengthOk);
        System.out.println(combined.validate("ORD-20261012")); // true
        System.out.println(combined.validate("ABC"));          // false
    }
}

import java.io.*;

// 实现 Serializable 表示「我允许被序列化」，真正的读写逻辑由 ObjectOutputStream 完成
class User implements Serializable {
    // serialVersionUID 是版本指纹，类结构变化但指纹一致时仍可反序列化
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password; // transient 字段被序列化机制跳过

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', password='" + password + "'}";
    }
}

class SerializeDemo {
    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            oos.writeObject(new User("张三", "123456"));
        }
        try (ObjectInputStream ois =
                 new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()))) {
            User u = (User) ois.readObject();
            System.out.println(u); // password 为 null，被 transient 跳过
        }
    }
}

import static java.lang.Math.PI;   // 静态导入：可以直接写 PI、max 而不带类名

public class StaticDemo {
    static int count = 0;                       // 静态字段：全类共享一份
    final int instanceId;                       // 实例字段：每个对象一份

    static {                                    // 静态代码块：类初始化时执行一次
        System.out.println("静态代码块执行");
        count = 100;
    }

    {                                           // 实例代码块：每次 new 都执行
        instanceId = ++count;
    }

    static int maxOf(int a, int b) {            // 静态方法：不能访问实例成员
        return Math.max(a, b);
    }

    // 静态嵌套类：不持有外部类引用
    static class Config {
        String host = "localhost";
    }

    public static void main(String[] args) {
        System.out.println(PI);                 // 静态导入生效
        System.out.println(maxOf(3, 5));
        System.out.println(new StaticDemo().instanceId);
        System.out.println(new StaticDemo().instanceId);
    }
}

public class FinalDemo {
    // 1. final 变量：基本类型值不可变，引用类型「引用不可变」但对象内容可变
    final int a = 1;
    final StringBuilder sb = new StringBuilder("ok");

    // 2. 编译期常量：static final + 基本类型/String + 字面量赋值
    static final int COMPILE_TIME = 10;
    // 3. 运行期常量：值需要运行期计算，不会被折叠
    static final int RUNTIME = new java.util.Random().nextInt(100);

    // 4. final 方法：禁止子类重写（private 方法隐式 final）
    final void cannotOverride() {}

    public void demo(final int param) {
        // 5. final 参数：方法内不能重新赋值，常用于匿名内部类/Lambda 捕获语义的显式表达
        // param = 2; // 编译错误
        sb.append("-changed");       // 合法：对象内容可变
        // sb = new StringBuilder(); // 编译错误：引用不可变
        System.out.println(sb + " " + param);
    }
}

// 6. final 类：禁止继承，String、Integer 都是 final 类
final class ImmutablePoint {
    private final int x, y;
    public ImmutablePoint(int x, int y) { this.x = x; this.y = y; }
}

public class StringPoolDemo {
    public static void main(String[] args) {
        String s1 = "java";                    // 字面量，进字符串常量池
        String s2 = "java";                    // 复用池中对象
        String s3 = new String("java");        // 强制在堆上新建对象
        String s4 = s3.intern();               // 返回池中已有对象的引用

        System.out.println(s1 == s2);          // true
        System.out.println(s1 == s3);          // false
        System.out.println(s1 == s4);          // true

        String a = "ja", b = "va";
        String s5 = a + b;                     // 运行期拼接，产生新对象
        String s6 = "ja" + "va";               // 编译期常量折叠，等价于 "java"
        System.out.println(s5 == s1);          // false
        System.out.println(s6 == s1);          // true
    }
}

public class Outer {
    private String name = "outer";
    private int value = 42;

    // 成员内部类：与外部类的某个实例绑定
    public class Inner {
        private int value = 100;

        public void print() {
            // 同名时：局部变量 > 内部类字段 > 外部类字段
            System.out.println("内部类字段 value = " + value);
            System.out.println("外部类字段 value = " + Outer.this.value);
            System.out.println("外部类私有字段 name = " + name); // 直接访问私有成员
        }
    }

    public Inner newInner() {
        return new Inner();   // 等价于 new Outer().new Inner() 中的 this.new Inner()
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.newInner();   // 必须通过外部实例创建
        inner.print();
    }
}

public class UserEntity {
    private final String name;
    private final int age;

    private UserEntity(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    // 静态内部类：不依赖外部实例，可以独立 new，不会造成外部类泄漏
    public static class Builder {
        private String name;
        private int age;

        public Builder name(String name) { this.name = name; return this; }
        public Builder age(int age) { this.age = age; return this; }
        public UserEntity build() { return new UserEntity(this); }
    }

    // 静态内部类实现懒加载单例：类加载时才创建，天然线程安全
    private static class Holder {
        static final UserEntity DEFAULT = new Builder().name("anonymous").age(0).build();
    }

    public static UserEntity defaultUser() {
        return Holder.DEFAULT;
    }
}

public class LocalInnerDemo {
    public static void main(String[] args) {
        final String prefix = "[LOG] ";   // JDK 8 起 final 可省略，但必须是 effectively final

        // 局部内部类：作用域仅限于本方法
        class Formatter {
            String format(String msg) {
                // 捕获的局部变量必须是 final 或 effectively final
                return prefix + msg;
            }
        }

        Formatter f = new Formatter();
        System.out.println(f.format("系统启动"));
        // prefix = "[X]"; // 一旦重新赋值，上一行捕获处立即编译错误
    }
}

import java.util.*;

public class AnonymousDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(Arrays.asList("bob", "alice", "carl"));

        // JDK 8 之前：用匿名内部类实现比较器，编译后生成 AnonymousDemo$1.class
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return a.compareTo(b);
            }
        });

        // JDK 8 之后：Lambda，语义等价但无额外 class 文件
        names.sort((a, b) -> a.compareTo(b));

        // 匿名内部类还能继承类（Lambda 只能实现接口），这是它不可完全替代的场景
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时任务执行于 " + new Date());
            }
        };
        task.run();   // 直接执行，避免启动 Timer 线程导致进程无法退出
        System.out.println("生成的内部类: " + task.getClass().getName());
    }
}

import java.lang.ref.WeakReference;
import java.util.concurrent.*;

public class LeakDemo {
    private byte[] bigData = new byte[1024 * 1024]; // 模拟大对象

    // 错误示范：非静态内部类，且被静态线程池持有 -> bigData 永远无法回收
    public Runnable leakyTask() {
        return new Runnable() {
            @Override
            public void run() {
                System.out.println("处理数据大小: " + bigData.length);
            }
        };
    }

    // 正确示范一：静态内部类，不持有外部引用，需要的数据作为参数传入
    public static class SafeTask implements Runnable {
        private final int size;
        SafeTask(int size) { this.size = size; }

        @Override
        public void run() {
            System.out.println("处理数据大小: " + size);
        }
    }

    // 正确示范二：静态内部类 + 弱引用，既需要外部状态又不阻止回收
    public static class WeakTask implements Runnable {
        private final WeakReference<LeakDemo> ref;
        WeakTask(LeakDemo demo) { this.ref = new WeakReference<>(demo); }

        @Override
        public void run() {
            LeakDemo demo = ref.get();
            if (demo != null) {
                System.out.println("处理数据大小: " + demo.bigData.length);
            }
        }
    }

    public Runnable safeTask() {
        return new WeakTask(this);
    }
}

class Parent {
    static String ps = print("1. 父类静态字段");
    String pi = print("4. 父类实例字段");

    static { print("2. 父类静态代码块"); }
    { print("5. 父类实例代码块"); }

    public Parent() {
        print("6. 父类构造器");
    }

    static String print(String s) {
        System.out.println(s);
        return s;
    }
}

public class InitOrderDemo extends Parent {
    static String cs = print("3. 子类静态字段");
    String ci = print("7. 子类实例字段");

    static { print("8. 子类静态代码块"); }   // 注意：静态块与静态字段按出现顺序交替执行
    { print("9. 子类实例代码块"); }

    public InitOrderDemo() {
        print("10. 子类构造器");
    }

    public static void main(String[] args) {
        System.out.println("--- 第一次 new ---");
        new InitOrderDemo();
        System.out.println("--- 第二次 new ---");
        new InitOrderDemo();
    }
}

public class StaticOnceDemo {
    private static int counter = 0;

    static {
        counter++;
        System.out.println("静态代码块执行, counter=" + counter);
    }

    public StaticOnceDemo() {
        System.out.println("构造器执行");
    }

    public static void main(String[] args) throws Exception {
        new StaticOnceDemo();
        new StaticOnceDemo();
        new StaticOnceDemo();
        // 即使再次触发类加载，初始化也只发生一次
        Class.forName("StaticOnceDemo");
        System.out.println("最终 counter = " + counter); // 始终是 1
    }
}

public enum OrderStatus {
    CREATED, PAID, SHIPPED, FINISHED, CANCELLED;

    public static void main(String[] args) {
        // values() 返回编译器生成的 $VALUES 数组的克隆
        for (OrderStatus s : OrderStatus.values()) {
            // name()/ordinal() 来自 Enum 父类，ordinal 是声明顺序，从 0 开始
            System.out.println(s.name() + " -> " + s.ordinal());
        }

        // valueOf 按 name 精确匹配，找不到抛 IllegalArgumentException
        OrderStatus paid = OrderStatus.valueOf("PAID");
        System.out.println(paid == OrderStatus.PAID); // true，枚举常量全局唯一

        // 枚举自带 Comparable（按 ordinal）与 toString
        System.out.println(OrderStatus.CREATED.compareTo(OrderStatus.PAID));
    }
}

public enum ResultCode {
    SUCCESS(200, "成功"),
    PARAM_ERROR(400, "参数错误"),
    NOT_FOUND(404, "资源不存在"),
    SERVER_ERROR(500, "服务器异常");

    // 枚举构造器必须是 private（省略也默认 private），不允许外部创建实例
    private final int code;
    private final String desc;

    ResultCode(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public int getCode() { return code; }
    public String getDesc() { return desc; }

    // 自定义查找方法，比直接用 ordinal 做映射可靠得多
    public static ResultCode of(int code) {
        for (ResultCode rc : values()) {
            if (rc.code == code) {
                return rc;
            }
        }
        throw new IllegalArgumentException("未知状态码: " + code);
    }
}

public enum ConfigSingleton {
    INSTANCE;

    private final java.util.Properties props = new java.util.Properties();

    ConfigSingleton() {
        props.setProperty("env", "prod");
    }

    public String get(String key) {
        return props.getProperty(key);
    }

    public static void main(String[] args) throws Exception {
        System.out.println(ConfigSingleton.INSTANCE.get("env"));

        // 尝试反射破坏
        java.lang.reflect.Constructor<ConfigSingleton> c =
                ConfigSingleton.class.getDeclaredConstructor();
        c.setAccessible(true);
        try {
            c.newInstance();  // 抛出 IllegalArgumentException
        } catch (Exception e) {
            System.out.println("反射创建失败: " + e.getMessage());
        }
    }
}

import java.util.*;

public class EnumCollectionDemo {
    enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

    public static void main(String[] args) {
        // EnumMap：内部是定长数组，以 ordinal 为下标，比 HashMap 快且无哈希冲突
        EnumMap<Day, String> schedule = new EnumMap<>(Day.class);
        schedule.put(Day.MON, "需求评审");
        schedule.put(Day.FRI, "周会");
        System.out.println(schedule.get(Day.MON));

        // EnumSet：内部用位向量（long 或 long[]）实现，极端节省内存
        EnumSet<Day> weekend = EnumSet.of(Day.SAT, Day.SUN);
        System.out.println(weekend.contains(Day.SAT));  // true
        System.out.println(EnumSet.complementOf(weekend)); // 工作日集合
    }
}

public enum PayrollDay {
    MONDAY(PayType.WEEKDAY), TUESDAY(PayType.WEEKDAY), WEDNESDAY(PayType.WEEKDAY),
    THURSDAY(PayType.WEEKDAY), FRIDAY(PayType.WEEKDAY),
    SATURDAY(PayType.WEEKEND), SUNDAY(PayType.WEEKEND);

    private final PayType payType;

    PayrollDay(PayType payType) {
        this.payType = payType;
    }

    // 委托给策略枚举，新增星期时编译器强制要求指定 PayType
    public double pay(double hoursWorked, double hourlyRate) {
        return payType.pay(hoursWorked, hourlyRate);
    }

    // 策略枚举：内嵌枚举，描述「工资计算策略」而不是「某一天」
    private enum PayType {
        WEEKDAY {
            @Override
            double overtimePay(double hours, double rate) {
                // 工作日超出 8 小时的部分算加班
                return hours <= HOURS_PER_SHIFT ? 0 : (hours - HOURS_PER_SHIFT) * rate / 2;
            }
        },
        WEEKEND {
            @Override
            double overtimePay(double hours, double rate) {
                // 周末全部工时按 1.5 倍计
                return hours * rate / 2;
            }
        };

        private static final int HOURS_PER_SHIFT = 8;

        abstract double overtimePay(double hours, double rate);

        double pay(double hoursWorked, double hourlyRate) {
            double basePay = hoursWorked * hourlyRate;
            return basePay + overtimePay(hoursWorked, hourlyRate);
        }
    }

    public static void main(String[] args) {
        System.out.println("周五工作 10 小时: " + PayrollDay.FRIDAY.pay(10, 100));
        System.out.println("周日工作 10 小时: " + PayrollDay.SUNDAY.pay(10, 100));
    }
}

import java.util.function.*;
import java.util.*;

public class LambdaDemo {
    public static void main(String[] args) {
        // 完整形态：参数类型 + 返回
        Function<String, Integer> f1 = (String s) -> { return s.length(); };
        // 推断形态：编译器从目标类型 Function<String,Integer> 推出参数类型
        Function<String, Integer> f2 = s -> s.length();

        Predicate<String> notBlank = s -> s != null && !s.trim().isEmpty();
        Consumer<String> printer = s -> System.out.println("消费: " + s);
        Supplier<List<String>> factory = ArrayList::new;

        List<String> data = Arrays.asList("java", "", "spring", null);
        // 组合使用
        data.stream()
            .filter(notBlank)
            .map(f2)
            .forEach(len -> printer.accept("长度=" + len));

        System.out.println(factory.get().getClass().getSimpleName());
    }
}

import java.util.function.*;
import java.util.*;

public class MethodRefDemo {
    static void staticPrint(String s) { System.out.println("[静态] " + s); }
    void instancePrint(String s) { System.out.println("[实例] " + s); }

    public static void main(String[] args) {
        List<String> list = Arrays.asList("b", "a", "c");

        // 1. 静态方法引用：类名::静态方法
        Consumer<String> c1 = MethodRefDemo::staticPrint;

        // 2. 实例方法引用（特定对象）：对象::实例方法
        MethodRefDemo demo = new MethodRefDemo();
        Consumer<String> c2 = demo::instancePrint;

        // 3. 任意对象的实例方法引用：类名::实例方法（第一个参数成为调用者）
        Function<String, String> upper = String::toUpperCase;
        Comparator<String> cmp = String::compareTo;

        // 4. 构造器引用：类名::new
        Supplier<ArrayList<String>> ctor = ArrayList::new;
        Function<String, StringBuilder> sbCtor = StringBuilder::new;

        list.forEach(c1);
        list.forEach(c2);
        System.out.println(upper.apply("lambda"));
        System.out.println(ctor.get().getClass().getSimpleName());
        System.out.println(sbCtor.apply("ok").append("!"));
    }
}

public class LambdaVsAnonymous {
    private String name = "外部类字段";

    public void compare() {
        // 匿名内部类：有自己的 this，指向内部类实例
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类 this = " + this.getClass().getName());
                System.out.println("访问外部字段: " + LambdaVsAnonymous.this.name);
            }
        };

        // Lambda：没有自己的 this，this 就是外部类的 this
        Runnable r2 = () -> {
            System.out.println("Lambda 中的 this = " + this.getClass().getName());
            System.out.println("直接访问外部字段: " + name);
        };

        r1.run();
        r2.run();
    }

    public static void main(String[] args) {
        new LambdaVsAnonymous().compare();
    }
}