继承与多态 ⭐

// 父类（基类 / 超类，Superclass）
public class Animal {
    // 成员变量：名字和年龄
    String name;
    int age;
 
    // 父类的普通方法
    public void eat() {
        // 所有动物都会吃东西
        System.out.println(name + " is eating.");
    }
 
    // 父类的另一个方法
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// 子类（派生类，Subclass）通过 extends 继承父类
public class Cat extends Animal {
    // Cat 特有的属性
    String furColor;
 
    // Cat 特有的方法
    public void purr() {
        // 猫咪特有的呼噜声
        System.out.println(name + " is purring~");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建子类对象
        Cat cat = new Cat();
        // name 是从 Animal 继承来的字段，Cat 自身并没有定义它
        cat.name = "Whiskers";
        // age 同样继承自 Animal
        cat.age = 3;
        // furColor 是 Cat 自己定义的字段
        cat.furColor = "Orange";
 
        // 调用从父类继承的方法 —— Cat 并没有定义 eat()
        cat.eat();   // 输出: Whiskers is eating.
        // 调用从父类继承的方法
        cat.sleep(); // 输出: Whiskers is sleeping.
        // 调用 Cat 自己定义的方法
        cat.purr();  // 输出: Whiskers is purring~
    }
}

public class Animal {
    // private 字段：子类无法直接访问
    private int heartRate = 80;
 
    // 通过 protected 方法暴露给子类
    protected int getHeartRate() {
        // 子类可以调用这个方法来获取 heartRate
        return heartRate;
    }
}

public class Cat extends Animal {
    public void showHeartRate() {
        // System.out.println(heartRate); // ❌ 编译错误！无法直接访问 private 字段
        System.out.println(getHeartRate()); // ✅ 通过继承的 protected 方法间接访问
    }
}

// ❌ 编译错误！Java 不允许多继承
// public class Liger extends Lion, Tiger { }

        Animal
       /      \
    Lion      Tiger
       \      /
        Liger (?)

// 通过接口实现"多继承"的效果
interface Swimmable {
    // 接口中定义游泳行为
    void swim();
}
 
interface Climbable {
    // 接口中定义攀爬行为
    void climb();
}
 
// Cat 继承 Animal（单继承），同时实现多个接口
public class Cat extends Animal implements Swimmable, Climbable {
    @Override
    public void swim() {
        // 实现游泳行为
        System.out.println(name + " is swimming reluctantly...");
    }
 
    @Override
    public void climb() {
        // 实现攀爬行为
        System.out.println(name + " climbed up the tree!");
    }
}

public class Animal {
    String name;
    int age;
 
    // 父类的有参构造方法
    public Animal(String name, int age) {
        // 初始化父类的字段
        this.name = name;
        this.age = age;
        System.out.println("Animal constructor called");
    }
}

public class Cat extends Animal {
    String furColor;
 
    // 子类构造方法
    public Cat(String name, int age, String furColor) {
        // 必须在第一行调用父类构造方法
        // 因为 Animal 没有无参构造，所以必须显式调用 super(name, age)
        super(name, age);
        // 然后初始化子类自己的字段
        this.furColor = furColor;
        System.out.println("Cat constructor called");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建 Cat 对象时，构造方法的调用顺序：
        // 1. 先执行 Animal(String, int) —— 父类构造
        // 2. 再执行 Cat(String, int, String) —— 子类构造
        Cat cat = new Cat("Mimi", 2, "White");
        // 输出:
        // Animal constructor called
        // Cat constructor called
    }
}

public class Animal {
    // 只有有参构造，没有无参构造
    public Animal(String name) {
        this.name = name;
    }
}

public class Cat extends Animal {
    // ❌ 编译错误！
    // 编译器自动插入 super()，但 Animal 没有无参构造方法
    public Cat() {
        // 隐式的 super() 找不到 Animal() —— 报错
    }
}

public class Animal {
    // 父类的 type 字段
    String type = "Animal";
}

public class Cat extends Animal {
    // 子类定义了同名字段，隐藏了父类的 type
    String type = "Cat";
 
    public void showTypes() {
        // 访问子类自己的 type
        System.out.println("this.type = " + this.type);   // Cat
        // 通过 super 访问被隐藏的父类 type
        System.out.println("super.type = " + super.type); // Animal
    }
}

public class Animal {
    public void makeSound() {
        // 父类的通用实现
        System.out.println("Some generic animal sound...");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        // 先调用父类的实现（复用已有逻辑）
        super.makeSound();
        // 再添加子类特有的行为
        System.out.println("Meow~ Meow~");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();
        // 输出:
        // Some generic animal sound...
        // Meow~ Meow~
    }
}

public class Cat extends Animal {
    // ❌ 编译错误！静态方法中不能使用 super
    public static void staticMethod() {
        // super.eat(); // 报错：non-static variable super cannot be referenced from a static context
    }
}

class A {
    String name = "A";
    public A() {
        System.out.println("A() called");
    }
}
 
class B extends A {
    String name = "B";
    public B() {
        System.out.println("B() called");
    }
    public void print() {
        System.out.println(super.name);
        System.out.println(this.name);
    }
}
 
public class Main {
    public static void main(String[] args) {
        B b = new B();
        b.print();
    }
}

class Animal {
    // 父类定义 speak 方法
    public String speak() {
        return "...";  // 动物发出声音
    }
}
 
class Dog extends Animal {
    // ✅ 正确重写：方法名、参数列表、返回类型完全一致
    @Override
    public String speak() {
        return "Woof!";  // 狗的叫声
    }
}
 
class Cat extends Animal {
    // ❌ 这不是重写，这是重载！参数列表不同
    public String speak(int volume) {
        return "Meow!";  // 这是一个新方法，不会覆盖父类的 speak()
    }
}

private < (default/package-private) < protected < public

class Parent {
    // 父类方法是 protected 级别
    protected void doSomething() {
        System.out.println("Parent doSomething");
    }
}
 
class ChildCorrect extends Parent {
    // ✅ public > protected，权限放大，合法
    @Override
    public void doSomething() {
        System.out.println("Child doSomething (public)");
    }
}
 
class ChildWrong extends Parent {
    // ❌ 编译错误！(default) < protected，权限缩小
    // 错误信息：attempting to assign weaker access privileges
    @Override
    void doSomething() {
        System.out.println("Child doSomething (default)");
    }
}

import java.io.*;
 
class DataReader {
    // 父类声明抛出 IOException
    public void readData() throws IOException {
        // 读取数据的通用逻辑
    }
}
 
class FileDataReader extends DataReader {
    // ✅ FileNotFoundException 是 IOException 的子类，异常范围缩小
    @Override
    public void readData() throws FileNotFoundException {
        // 从文件读取数据
    }
}
 
class NetworkDataReader extends DataReader {
    // ✅ 完全不抛异常也合法，相当于异常范围缩小到零
    @Override
    public void readData() {
        // 从网络读取数据，内部自行处理异常
    }
}
 
class BrokenReader extends DataReader {
    // ❌ 编译错误！Exception 比 IOException 范围更大
    // @Override
    // public void readData() throws Exception { }
}

class Base {
    // static 方法属于类，不属于实例，无法被重写（只能被"隐藏" Method Hiding）
    public static void staticMethod() {
        System.out.println("Base static");
    }
 
    // final 方法被显式禁止重写，编译器会直接报错
    public final void finalMethod() {
        System.out.println("Base final");
    }
 
    // private 方法对子类不可见，子类中的同名方法是全新方法，不构成重写
    private void privateMethod() {
        System.out.println("Base private");
    }
}
 
class Derived extends Base {
    // 这不是重写，是方法隐藏（Method Hiding）
    // 调用哪个版本取决于引用类型，而非对象类型
    public static void staticMethod() {
        System.out.println("Derived static");
    }
 
    // ❌ 编译错误：Cannot override the final method from Base
    // @Override
    // public void finalMethod() { }
 
    // 这是一个全新的方法，与父类的 privateMethod 毫无关系
    public void privateMethod() {
        System.out.println("Derived 'private' — actually a new method");
    }
}

public class HidingVsOverriding {
    public static void main(String[] args) {
        Base ref = new Derived();  // 父类引用指向子类对象
 
        // static 方法：看引用类型（编译时类型），输出 "Base static"
        ref.staticMethod();
 
        // 如果是实例方法重写：看对象类型（运行时类型）
        // 这就是隐藏与重写的本质区别
    }
}

class Person {
    private String name;  // 姓名
    private int age;      // 年龄
 
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    // 我们想重写 Object 的 equals 方法...
    // ❌ 注意看参数类型！这里写成了 Person 而不是 Object
    public boolean equals(Person other) {
        if (other == null) return false;
        return this.name.equals(other.name) && this.age == other.age;
    }
}

class Person {
    private String name;
    private int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    // ✅ 加上 @Override，编译器立刻发现这不是合法的重写
    // 编译错误：Method does not override method from its superclass
    @Override
    public boolean equals(Person other) {  // ← 编译器在这里报错
        if (other == null) return false;
        return this.name.equals(other.name) && this.age == other.age;
    }
}

class Person {
    private String name;
    private int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public boolean equals(Object obj) {          // 参数类型必须是 Object
        if (this == obj) return true;             // 同一引用，直接返回 true
        if (obj == null) return false;            // null 检查
        if (getClass() != obj.getClass()) return false;  // 类型检查
        Person other = (Person) obj;              // 安全向下转型
        return this.name.equals(other.name)       // 逐字段比较
            && this.age == other.age;
    }
 
    @Override
    public int hashCode() {                       // 重写 equals 必须同时重写 hashCode
        return Objects.hash(name, age);           // 使用相同字段计算哈希值
    }
}

interface Drawable {
    void draw();  // 接口中的抽象方法
}
 
class Circle implements Drawable {
    @Override   // ✅ Java 6+ 支持在实现接口方法时使用 @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

@Target(ElementType.METHOD)      // 只能用在方法上
@Retention(RetentionPolicy.SOURCE) // 只在源码阶段存在，编译后丢弃
public @interface Override {
    // 空的，没有任何属性
}

┌─────────────────────────────────────┐
│        Animal 的方法表 (vtable)       │
├──────────┬──────────────────────────┤
│  slot 0  │  Object.toString()       │
│  slot 1  │  Object.equals()         │
│  slot 2  │  Animal.speak() ─────────┼──→ return "..."
│  slot 3  │  Animal.eat()            │
└──────────┴──────────────────────────┘
 
┌─────────────────────────────────────┐
│         Dog 的方法表 (vtable)         │
├──────────┬──────────────────────────┤
│  slot 0  │  Object.toString()       │  ← 继承，未重写
│  slot 1  │  Object.equals()         │  ← 继承，未重写
│  slot 2  │  Dog.speak() ────────────┼──→ return "Woof!"  (重写！指针替换)
│  slot 3  │  Animal.eat()            │  ← 继承，未重写
└──────────┴──────────────────────────┘

// 抽象基类：图形
abstract class Shape {
    protected String color;  // 颜色
 
    public Shape(String color) {
        this.color = color;  // 通过构造方法初始化颜色
    }
 
    // 抽象方法：计算面积，子类必须重写
    public abstract double area();
 
    // 普通方法：描述图形信息，子类可选择重写
    public String describe() {
        // 调用 area()，运行时会动态绑定到子类的实现
        return color + " shape with area = " + area();
    }
}
 
// 圆形
class Circle extends Shape {
    private double radius;  // 半径
 
    public Circle(String color, double radius) {
        super(color);        // 调用父类构造方法
        this.radius = radius;
    }
 
    @Override
    public double area() {
        // 圆的面积公式：π * r²
        return Math.PI * radius * radius;
    }
 
    @Override
    public String describe() {
        // 重写 describe，提供更具体的描述
        return color + " circle (r=" + radius + "), area = "
               + String.format("%.2f", area());
    }
}
 
// 矩形
class Rectangle extends Shape {
    private double width;   // 宽
    private double height;  // 高
 
    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
 
    @Override
    public double area() {
        // 矩形面积：宽 × 高
        return width * height;
    }
    // 没有重写 describe()，直接继承父类的实现
}
 
// 测试
public class ShapeDemo {
    public static void main(String[] args) {
        // 父类引用指向不同子类对象——多态的体现
        Shape s1 = new Circle("Red", 5.0);       // 红色圆形
        Shape s2 = new Rectangle("Blue", 4.0, 6.0); // 蓝色矩形
 
        // 调用 describe()，运行时动态绑定到各自的实现
        System.out.println(s1.describe());
        // 输出：Red circle (r=5.0), area = 78.54
 
        System.out.println(s2.describe());
        // 输出：Blue shape with area = 24.0
        // Rectangle 没有重写 describe()，走的是父类逻辑
        // 但父类 describe() 内部调用的 area() 仍然绑定到 Rectangle.area()
 
        // 用数组统一管理不同图形
        Shape[] shapes = { s1, s2, new Circle("Green", 3.0) };
        double totalArea = 0;
        for (Shape s : shapes) {
            totalArea += s.area();  // 每次调用都动态分派到正确的子类实现
        }
        System.out.println("Total area = " + String.format("%.2f", totalArea));
        // 输出：Total area = 130.81
    }
}

class Parent {
    public Parent() {
        // 构造方法中调用了可被重写的方法——危险！
        init();
    }
 
    // 这个方法可以被子类重写
    public void init() {
        System.out.println("Parent init");
    }
}
 
class Child extends Parent {
    private String value;  // 子类自己的字段
 
    public Child(String value) {
        super();            // 先调用父类构造方法
        this.value = value; // 然后才初始化子类字段
    }
 
    @Override
    public void init() {
        // 此时 value 还是 null！因为子类字段尚未初始化
        System.out.println("Child init, value = " + value);
    }
}
 
public class ConstructorTrap {
    public static void main(String[] args) {
        Child c = new Child("Hello");
        // 输出：Child init, value = null   ← 不是 "Hello"！
    }
}

/*
 * 方法重写最佳实践清单：
 *
 * 1. 始终使用 @Override 注解
 *    → 让编译器帮你检查，零成本的安全保障
 *
 * 2. 遵循里氏替换原则 (LSP)
 *    → 子类重写后的行为应该符合父类方法的"契约"
 *    → 不要在重写中做出与父类语义完全矛盾的事情
 *
 * 3. 构造方法中避免调用可重写方法
 *    → 用 private 或 final 方法代替
 *
 * 4. 重写 equals() 必须同时重写 hashCode()
 *    → 现代 IDE 都能自动生成，善用工具
 *
 * 5. 善用 super 调用父类原始实现
 *    → 重写不意味着完全抛弃父类逻辑
 *    → 很多时候是"在父类基础上增强"
 */

class LoggingList extends ArrayList<String> {
    @Override
    public boolean add(String element) {
        // 在父类逻辑之前增加日志功能
        System.out.println("[LOG] Adding element: " + element);
        // 调用父类的原始 add 实现，完成真正的添加操作
        return super.add(element);
    }
}

class A {
    public void show() {
        System.out.print("A ");
        display();
    }
    public void display() {
        System.out.print("A.display ");
    }
}
 
class B extends A {
    @Override
    public void display() {
        System.out.print("B.display ");
    }
}
 
public class Test {
    public static void main(String[] args) {
        A obj = new B();
        obj.show();
    }
}

// 三层继承结构演示
class Grandparent {
    int a;
 
    // 祖父类构造方法
    Grandparent() {
        this.a = 1;
        System.out.println("Grandparent 构造完成, a = " + a);
    }
}
 
class Parent extends Grandparent {
    int b;
 
    // 父类构造方法——在执行自己的逻辑前，会先隐式调用 super()
    Parent() {
        // 编译器在这里自动插入了 super(); 调用 Grandparent()
        this.b = 2;
        System.out.println("Parent 构造完成, b = " + b);
    }
}
 
class Child extends Parent {
    int c;
 
    // 子类构造方法——同样会先隐式调用 super()
    Child() {
        // 编译器在这里自动插入了 super(); 调用 Parent()
        this.c = 3;
        System.out.println("Child 构造完成, c = " + c);
    }
}
 
public class ChainDemo {
    public static void main(String[] args) {
        // 只写了一行 new，但触发了三层构造方法
        Child child = new Child();
        // 输出：
        // Grandparent 构造完成, a = 1
        // Parent 构造完成, b = 2
        // Child 构造完成, c = 3
    }
}

// 你写的代码
class Child extends Parent {
    Child() {
        System.out.println("Child");
    }
}
 
// 编译器实际处理后的等价代码
class Child extends Parent {
    Child() {
        super();  // 编译器自动插入
        System.out.println("Child");
    }
}

class Parent {
    String name;
 
    // 父类只有一个带参构造方法，没有无参构造方法
    Parent(String name) {
        this.name = name;
    }
}
 
class Child extends Parent {
    // ❌ 编译错误！
    // 编译器试图插入 super()，但 Parent 没有无参构造方法
    Child() {
        System.out.println("Child");
    }
}

// 方式一：在子类中显式调用父类的带参构造方法
class Child extends Parent {
    Child() {
        super("default");  // 显式调用，必须是第一行
        System.out.println("Child");
    }
}
 
// 方式二：给父类补一个无参构造方法
class Parent {
    String name;
 
    Parent() {           // 补上无参构造
        this.name = "unknown";
    }
 
    Parent(String name) {
        this.name = name;
    }
}

class Employee {
    String name;
    int age;
    String department;
 
    // 构造方法 1：全参构造（最终的"终点"，负责调用 super）
    Employee(String name, int age, String department) {
        super();  // 调用 Object 的构造方法（可省略，编译器自动插入）
        this.name = name;
        this.age = age;
        this.department = department;
        System.out.println("全参构造执行");
    }
 
    // 构造方法 2：双参构造 → 委托给全参构造
    Employee(String name, int age) {
        this(name, age, "未分配");  // 调用构造方法 1
        System.out.println("双参构造执行");
    }
 
    // 构造方法 3：无参构造 → 委托给双参构造
    Employee() {
        this("匿名", 0);  // 调用构造方法 2
        System.out.println("无参构造执行");
    }
}

class Parent {
    // ① 静态变量与静态初始化块（类加载时执行，只执行一次）
    static int staticVar = initStaticVar();
    static {
        System.out.println("2. Parent 静态初始化块");
    }
 
    // ③ 实例变量与实例初始化块（每次 new 都执行）
    int instanceVar = initInstanceVar();
    {
        System.out.println("5. Parent 实例初始化块");
    }
 
    // ④ 构造方法
    Parent() {
        System.out.println("6. Parent 构造方法");
    }
 
    static int initStaticVar() {
        System.out.println("1. Parent 静态变量初始化");
        return 1;
    }
 
    int initInstanceVar() {
        System.out.println("4. Parent 实例变量初始化");
        return 2;
    }
}
 
class Child extends Parent {
    // ② 子类静态变量与静态初始化块
    static int staticVar = initStaticVar();
    static {
        System.out.println("3-b. Child 静态初始化块");
    }
 
    // ⑤ 子类实例变量与实例初始化块
    int instanceVar = initInstanceVar();
    {
        System.out.println("8. Child 实例初始化块");
    }
 
    // ⑥ 子类构造方法
    Child() {
        // 隐式 super() → 触发 Parent 的实例初始化 + 构造方法
        System.out.println("9. Child 构造方法");
    }
 
    static int initStaticVar() {
        System.out.println("3-a. Child 静态变量初始化");
        return 3;
    }
 
    int initInstanceVar() {
        System.out.println("7. Child 实例变量初始化");
        return 4;
    }
}
 
public class InitOrderDemo {
    public static void main(String[] args) {
        System.out.println("===== 第一次 new Child =====");
        new Child();
        System.out.println("\n===== 第二次 new Child =====");
        new Child();
    }
}

class Base {
    Base() {
        System.out.println("Base 构造方法开始");
        // ⚠️ 危险：在构造方法中调用了可被重写的方法
        display();
        System.out.println("Base 构造方法结束");
    }
 
    void display() {
        System.out.println("Base.display()");
    }
}
 
class Derived extends Base {
    private int value = 42;  // 这个赋值在 super() 之后才执行！
 
    Derived() {
        // 隐式 super() → 调用 Base()
        // 此时 value 的赋值语句还没执行
        System.out.println("Derived 构造方法, value = " + value);
    }
 
    @Override
    void display() {
        // 当被 Base 构造方法调用时，value 还是默认值 0
        System.out.println("Derived.display(), value = " + value);
    }
}
 
public class TrapDemo {
    public static void main(String[] args) {
        new Derived();
    }
}

// 时间线：new Derived() 的内部过程
 
// Step 1: JVM 分配内存，所有字段置为默认值
// ┌─────────────────────────┐
// │  Derived 对象 (堆内存)    │
// │  ┌─────────────────────┐ │
// │  │ value = 0  (默认值)  │ │
// │  └─────────────────────┘ │
// └─────────────────────────┘
 
// Step 2: 执行 Base 构造方法 → 调用 display()
//         此时 value 仍然是 0 ！
 
// Step 3: Base 构造方法结束，回到 Derived
//         执行 Derived 的实例变量赋值：value = 42
// ┌─────────────────────────┐
// │  Derived 对象 (堆内存)    │
// │  ┌─────────────────────┐ │
// │  │ value = 42 (已赋值)  │ │
// │  └─────────────────────┘ │
// └─────────────────────────┘
 
// Step 4: 执行 Derived 构造方法体

class WellDesignedParent {
 
    private final String name;
    private final int id;
 
    // 原则 1：提供合理的无参构造（或文档说明为什么不提供）
    WellDesignedParent() {
        this("default", 0);  // 委托给全参构造
    }
 
    // 原则 2：使用 this() 链实现"望远镜构造模式"(Telescoping Constructor)
    WellDesignedParent(String name) {
        this(name, 0);  // 委托给全参构造
    }
 
    // 原则 3：全参构造作为唯一的"真正"初始化点
    WellDesignedParent(String name, int id) {
        // 原则 4：在构造方法中只调用 private/final 方法
        this.name = validate(name);
        this.id = id;
    }
 
    // private 方法不会被子类重写，在构造方法中调用是安全的
    private String validate(String input) {
        return (input == null || input.isEmpty()) ? "default" : input;
    }
}

class A {
    A() {
        System.out.print("A");
    }
}
 
class B extends A {
    B() {
        System.out.print("B");
    }
 
    B(String s) {
        this();
        System.out.print(s);
    }
}
 
class C extends B {
    C() {
        super("X");
        System.out.print("C");
    }
}
 
public class Quiz {
    public static void main(String[] args) {
        new C();
    }
}

// 声明一个 final 类
public final class MathConstants {
    // 圆周率，同时也是 final 变量
    public static final double PI = 3.141592653589793;
 
    // 自然对数底数
    public static final double E = 2.718281828459045;
 
    // 私有构造器，防止实例化（工具类常见写法）
    private MathConstants() {
        // 工具类不需要被实例化
    }
}

// ❌ 编译错误：Cannot inherit from final 'MathConstants'
public class ExtendedMath extends MathConstants {
    // ...
}

// ❌ 编译错误：Illegal combination of modifiers: 'abstract' and 'final'
public abstract final class Impossible {
    // 逻辑矛盾：既要求被继承，又禁止被继承
}

public class Transaction {
 
    private double amount; // 交易金额
 
    public Transaction(double amount) {
        this.amount = amount; // 构造时设定金额
    }
 
    // final 方法：核心验证逻辑不允许子类篡改
    public final boolean validate() {
        // 金额必须大于 0 且不超过单笔限额
        return amount > 0 && amount <= 1_000_000;
    }
 
    // 普通方法：子类可以自定义处理逻辑
    public void process() {
        System.out.println("Processing transaction: " + amount);
    }
}
 
public class InternationalTransaction extends Transaction {
 
    private String currency; // 币种
 
    public InternationalTransaction(double amount, String currency) {
        super(amount);          // 调用父类构造器
        this.currency = currency; // 设置币种
    }
 
    // ❌ 编译错误：Cannot override the final method from Transaction
    // @Override
    // public boolean validate() {
    //     return true; // 试图绕过验证 —— 被 final 阻止
    // }
 
    // ✅ 可以重写非 final 方法
    @Override
    public void process() {
        System.out.println("Processing international transaction in " + currency);
    }
}

public abstract class DataProcessor {
 
    // final 模板方法：定义处理流程的骨架，子类不能改变流程顺序
    public final void execute() {
        readData();      // 第一步：读取数据
        processData();   // 第二步：处理数据（子类实现）
        writeResult();   // 第三步：写出结果（子类实现）
        cleanup();       // 第四步：清理资源
    }
 
    // 固定实现：读取数据的通用逻辑
    private void readData() {
        System.out.println("Reading data from source...");
    }
 
    // 抽象方法：子类必须实现自己的处理逻辑
    protected abstract void processData();
 
    // 抽象方法：子类必须实现自己的输出逻辑
    protected abstract void writeResult();
 
    // 固定实现：清理资源
    private void cleanup() {
        System.out.println("Cleaning up resources...");
    }
}

public class FinalPrimitiveDemo {
    public static void main(String[] args) {
        final int maxRetry = 3;    // 声明并赋值，此后不可更改
        // maxRetry = 5;           // ❌ 编译错误：Cannot assign a value to final variable
 
        final double pi;           // 声明时可以不赋值（blank final）
        pi = 3.14159;              // 首次赋值 OK
        // pi = 3.14;              // ❌ 编译错误：Variable 'pi' might already have been assigned
 
        System.out.println("Max retry: " + maxRetry); // 输出: Max retry: 3
        System.out.println("PI: " + pi);               // 输出: PI: 3.14159
    }
}

import java.util.ArrayList;
import java.util.List;
 
public class FinalReferenceDemo {
    public static void main(String[] args) {
        // final 引用：list 永远指向这个 ArrayList 实例
        final List<String> list = new ArrayList<>();
 
        // ✅ 可以修改对象的内容（往 list 里添加元素）
        list.add("Java");         // list 的内容变了，但引用没变
        list.add("Python");       // 继续添加，完全合法
        list.add("Go");           // 没问题
 
        // ❌ 不能让 list 指向另一个对象
        // list = new ArrayList<>();  // 编译错误：Cannot assign a value to final variable
 
        System.out.println(list);  // 输出: [Java, Python, Go]
    }
}

// ===== final 引用类型的内存模型 =====
//
//  栈 (Stack)                    堆 (Heap)
//  ┌──────────────┐             ┌──────────────────────┐
//  │ final list   │────────────▶│  ArrayList 对象       │
//  │ (引用被锁定)  │      ×      │  ┌──────────────────┐ │
//  └──────────────┘     ╱       │  │ [0] "Java"       │ │
//         │            ╱        │  │ [1] "Python"     │ │  ← 内容可变!
//         │  不能重新指向        │  │ [2] "Go"         │ │
//         │            ╲        │  └──────────────────┘ │
//         │             ×       └──────────────────────┘
//         │
//         ╳─ ─ ─ ─ ─ ─ ─ ─ ─ ▷ new ArrayList<>()  ← 禁止!

public class Student {
 
    private final String name;   // blank final：声明时未赋值
    private final int id;        // blank final
 
    // 构造器中必须为所有 blank final 赋值
    public Student(String name, int id) {
        this.name = name;        // ✅ 在构造器中首次赋值
        this.id = id;            // ✅ 在构造器中首次赋值
    }
 
    // 如果有多个构造器，每个都必须赋值
    public Student(String name) {
        this.name = name;        // ✅ name 赋值了
        this.id = -1;            // ✅ id 也必须赋值，否则编译错误
    }
 
    // 普通方法中不能再修改
    public void tryModify() {
        // this.name = "New Name"; // ❌ 编译错误
    }
 
    public String getName() {
        return name;             // 返回 name
    }
 
    public int getId() {
        return id;               // 返回 id
    }
}

public class HttpStatus {
    // 静态常量：编译期常量（compile-time constant）
    public static final int OK = 200;                    // HTTP 200
    public static final int NOT_FOUND = 404;             // HTTP 404
    public static final int INTERNAL_ERROR = 500;        // HTTP 500
    public static final String DEFAULT_CHARSET = "UTF-8"; // 默认字符集
 
    // 静态常量也可以在静态代码块中赋值
    public static final long STARTUP_TIME;
 
    static {
        STARTUP_TIME = System.currentTimeMillis(); // 类加载时记录启动时间
    }
}

public class Calculator {
 
    // final 参数：方法内不能修改 a 和 b 的值
    public int add(final int a, final int b) {
        // a = 10;  // ❌ 编译错误：Cannot assign a value to final variable 'a'
        return a + b; // 只能读取，不能修改
    }
 
    // 在匿名内部类 / Lambda 中引用的局部变量必须是 effectively final
    public Runnable createTask(final String taskName) {
        // Lambda 捕获了 taskName，它必须是 final 或 effectively final
        return () -> System.out.println("Running: " + taskName);
    }
}

// 一个真正不可变的类示例
public final class ImmutablePoint {           // 1. 类声明为 final，防止子类破坏不可变性
 
    private final int x;                      // 2. 所有字段声明为 final
    private final int y;                      // 2. 所有字段声明为 final
 
    public ImmutablePoint(int x, int y) {     // 3. 构造器中完成所有赋值
        this.x = x;
        this.y = y;
    }
 
    public int getX() { return x; }          // 4. 只提供 getter，不提供 setter
    public int getY() { return y; }          // 4. 只提供 getter，不提供 setter
 
    // 5. 如果需要"修改"，返回新对象而非修改自身
    public ImmutablePoint translate(int dx, int dy) {
        return new ImmutablePoint(this.x + dx, this.y + dy); // 返回全新对象
    }
 
    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";     // 方便打印
    }
}

public class Animal {
 
    // final 方法：所有动物的呼吸方式相同，子类不能改
    public final void breathe() {
        System.out.println("Breathing...");   // 呼吸是固定行为
    }
 
    // 非 final 方法：不同动物叫声不同，子类可以重写
    public void makeSound() {
        System.out.println("Some sound...");  // 默认实现
    }
}
 
public class Dog extends Animal {
 
    // ❌ 不能重写 final 方法
    // @Override
    // public void breathe() { ... }
 
    // ✅ 可以重写非 final 方法，多态正常工作
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");    // 狗的叫声
    }
}
 
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();            // 向上转型
        animal.breathe();                     // 输出: Breathing...（final 方法，无多态）
        animal.makeSound();                   // 输出: Woof! Woof!（多态生效）
    }
}

public class FinalQuiz {
    public static void main(String[] args) {
        final int[] arr = {1, 2, 3};
        arr[0] = 99;
        arr[1] = 88;
        // arr = new int[]{4, 5, 6};
        System.out.println(arr[0] + ", " + arr[1] + ", " + arr[2]);
    }
}

// 父类：动物
class Animal {
    // 父类定义的通用方法
    public void speak() {
        System.out.println("动物发出声音"); // 默认实现
    }
}
 
// 子类：狗
class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("汪汪汪！"); // 狗的具体实现
    }
}
 
// 子类：猫
class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("喵喵喵！"); // 猫的具体实现
    }
}
 
public class PolymorphismDemo {
    public static void main(String[] args) {
        // 关键：左边是父类类型，右边是子类对象
        Animal a1 = new Dog();  // a1 的编译时类型是 Animal，运行时类型是 Dog
        Animal a2 = new Cat();  // a2 的编译时类型是 Animal，运行时类型是 Cat
 
        a1.speak(); // 输出：汪汪汪！ —— 调用的是 Dog 的 speak()
        a2.speak(); // 输出：喵喵喵！ —— 调用的是 Cat 的 speak()
    }
}

//    编译时类型          运行时类型
//       ↓                  ↓
      Animal           animal = new Dog();

class Shape {
    // 父类方法：计算面积
    public double area() {
        return 0.0; // 默认面积为 0
    }
 
    // 父类方法：获取名称
    public String getName() {
        return "Shape"; // 默认名称
    }
}
 
class Circle extends Shape {
    private double radius; // 半径
 
    // 构造方法，接收半径参数
    public Circle(double radius) {
        this.radius = radius; // 初始化半径
    }
 
    @Override
    public double area() {
        return Math.PI * radius * radius; // 圆的面积公式：π * r²
    }
 
    @Override
    public String getName() {
        return "Circle"; // 返回圆的名称
    }
 
    // Circle 独有的方法，父类中没有
    public double getRadius() {
        return radius; // 返回半径值
    }
}
 
public class TypeDemo {
    public static void main(String[] args) {
        Shape s = new Circle(5.0); // 编译时类型: Shape, 运行时类型: Circle
 
        // ✅ 可以调用 area() —— Shape 中声明了该方法，编译通过
        // 实际执行的是 Circle.area()，因为运行时类型是 Circle
        System.out.println(s.area());       // 输出: 78.5398...
 
        // ✅ 可以调用 getName() —— Shape 中声明了该方法
        System.out.println(s.getName());    // 输出: Circle
 
        // ❌ 编译错误！不能调用 getRadius()
        // 因为编译时类型是 Shape，Shape 中没有 getRadius() 方法
        // s.getRadius();  // 编译器报错: cannot find symbol
    }
}

class Parent {
    public String name = "Parent"; // 父类字段
 
    public String getName() {
        return name; // 返回父类的 name 字段
    }
}
 
class Child extends Parent {
    public String name = "Child"; // 子类定义了同名字段（这是隐藏，不是重写）
 
    @Override
    public String getName() {
        return name; // 返回子类的 name 字段
    }
}
 
public class FieldDemo {
    public static void main(String[] args) {
        Parent p = new Child(); // 编译时类型: Parent, 运行时类型: Child
 
        // 直接访问字段 —— 由编译时类型决定
        System.out.println(p.name);          // 输出: Parent（不是 Child！）
 
        // 调用方法 —— 由运行时类型决定（多态生效）
        System.out.println(p.getName());     // 输出: Child
    }
}

// 内存中 Child 对象的布局（简化示意）
// ┌──────────────────────────────────┐
// │         Child 对象实例            │
// ├──────────────────────────────────┤
// │  [对象头 Object Header]          │
// │  - 类型指针 → Child.class        │  ← JVM 靠这个找到运行时类型
// ├──────────────────────────────────┤
// │  Parent.name = "Parent"          │  ← p.name 访问的是这里（编译时类型决定）
// ├──────────────────────────────────┤
// │  Child.name  = "Child"           │  ← 子类同名字段，独立存储
// └──────────────────────────────────┘

class Base {
    // 静态方法
    public static void greet() {
        System.out.println("Hello from Base"); // 父类的静态方法
    }
 
    // 实例方法
    public void instanceGreet() {
        System.out.println("Instance: Base"); // 父类的实例方法
    }
}
 
class Derived extends Base {
    // 同签名的静态方法 —— 这是隐藏（Hiding），不是重写（Overriding）
    public static void greet() {
        System.out.println("Hello from Derived"); // 子类的静态方法
    }
 
    @Override
    public void instanceGreet() {
        System.out.println("Instance: Derived"); // 子类重写的实例方法
    }
}
 
public class StaticMethodDemo {
    public static void main(String[] args) {
        Base obj = new Derived(); // 编译时类型: Base, 运行时类型: Derived
 
        obj.greet();           // 输出: Hello from Base（静态方法看编译时类型）
        obj.instanceGreet();   // 输出: Instance: Derived（实例方法看运行时类型）
    }
}

class Shape {
    // 计算面积的通用方法
    public double area() {
        return 0.0; // 默认实现
    }
 
    // 绘制图形的通用方法
    public void draw() {
        System.out.println("Drawing a shape"); // 默认实现
    }
}
 
class Circle extends Shape {
    private double radius; // 圆的半径
 
    public Circle(double radius) {
        this.radius = radius; // 初始化半径
    }
 
    @Override
    public double area() {
        return Math.PI * radius * radius; // 圆面积: π * r²
    }
 
    @Override
    public void draw() {
        System.out.println("Drawing Circle with radius " + radius); // 绘制圆
    }
}
 
class Rectangle extends Shape {
    private double width;  // 矩形的宽
    private double height; // 矩形的高
 
    public Rectangle(double width, double height) {
        this.width = width;   // 初始化宽
        this.height = height; // 初始化高
    }
 
    @Override
    public double area() {
        return width * height; // 矩形面积: 宽 × 高
    }
 
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle " + width + "x" + height); // 绘制矩形
    }
}
 
class Triangle extends Shape {
    private double base;   // 三角形的底
    private double height; // 三角形的高
 
    public Triangle(double base, double height) {
        this.base = base;     // 初始化底
        this.height = height; // 初始化高
    }
 
    @Override
    public double area() {
        return 0.5 * base * height; // 三角形面积: 0.5 × 底 × 高
    }
 
    @Override
    public void draw() {
        System.out.println("Drawing Triangle with base " + base); // 绘制三角形
    }
}
 
public class ShapeSystem {
    // 关键方法：参数类型是父类 Shape
    // 它不关心传入的具体是什么图形，只要是 Shape 的子类就行
    public static void printInfo(Shape shape) {
        shape.draw();                                          // 多态调用 draw()
        System.out.println("Area = " + shape.area());         // 多态调用 area()
    }
 
    // 计算一组图形的总面积 —— 同样不关心具体类型
    public static double totalArea(Shape[] shapes) {
        double sum = 0;                    // 累加器
        for (Shape s : shapes) {           // 遍历每个图形
            sum += s.area();               // 多态调用，每个图形执行自己的 area()
        }
        return sum;                        // 返回总面积
    }
 
    public static void main(String[] args) {
        // 创建不同类型的图形对象
        Shape[] shapes = {
            new Circle(5),              // 圆
            new Rectangle(4, 6),        // 矩形
            new Triangle(3, 8)          // 三角形
        };
 
        // 统一处理，无需 if-else 判断具体类型
        for (Shape s : shapes) {
            printInfo(s);               // 多态自动选择正确的实现
            System.out.println("---");
        }
 
        // 计算总面积
        System.out.println("Total area = " + totalArea(shapes));
    }
}

// ❌ 没有多态的写法 —— 每新增一种图形就要改这个方法
public static void printInfoWithoutPolymorphism(Object shape) {
    if (shape instanceof Circle) {           // 判断是否是圆
        ((Circle) shape).draw();             // 强制转型后调用
    } else if (shape instanceof Rectangle) { // 判断是否是矩形
        ((Rectangle) shape).draw();          // 强制转型后调用
    } else if (shape instanceof Triangle) {  // 判断是否是三角形
        ((Triangle) shape).draw();           // 强制转型后调用
    }
    // 每新增一种图形，就要在这里加一个 else if... 噩梦！
}

class A {
    public int value = 10;           // A 的字段
 
    public int getValue() {
        return value;                // 返回 A 的 value
    }
}
 
class B extends A {
    public int value = 20;           // B 的字段（隐藏了 A 的 value）
 
    @Override
    public int getValue() {
        return value;                // 返回 B 的 value（这里的 value 指 B.value）
    }
}
 
public class TrapDemo {
    public static void main(String[] args) {
        A obj = new B();             // 编译时类型: A, 运行时类型: B
 
        System.out.println(obj.value);        // 10 —— 字段访问看编译时类型(A)
        System.out.println(obj.getValue());   // 20 —— 方法调用看运行时类型(B)
 
        // 两个结果不同！这就是字段隐藏和方法重写的本质区别
    }
}