002｜重载与重写：静态分派、动态分派、协变返回类型与方法选择规则

public class DispatchDemo {
    static class Animal {}
    static class Dog extends Animal {}
    static class Cat extends Animal {}

    public void greet(Animal a) { System.out.println("Hello Animal"); }
    public void greet(Dog d)    { System.out.println("Hello Dog"); }
    public void greet(Cat c)    { System.out.println("Hello Cat"); }


    public static void main(String[ ] args) {

        DispatchDemo demo = new DispatchDemo();
        Animal dog = new Dog();
        Animal cat = new Cat();

        demo.greet(dog);  // 输出 ① ?
        demo.greet(cat);  // 输出 ② ?
        demo.greet((Dog) dog);  // 输出 ③ ?
    }
}

public class Calculator {
    public int add(int a, int b)          { return a + b; }
    public double add(double a, double b)  { return a + b; }
    public int add(int a, int b, int c)    { return a + b + c; }
}

public class Animal {
    public void makeSound() { System.out.println("Some sound"); }
}

public class Dog extends Animal {
    @Override
    public void makeSound() { System.out.println("Woof!"); }
}

Animal dog = new Dog();    // 静态类型 = Animal，实际类型 = Dog
demo.greet(dog);           // 编译器只看静态类型 Animal → 调用 greet(Animal)

// 静态类型 vs 实际类型
Animal a = new Dog();   // 静态类型: Animal, 实际类型: Dog
Dog d = new Dog();      // 静态类型: Dog,    实际类型: Dog

demo.greet(a);  // 静态类型 Animal → greet(Animal)
demo.greet(d);  // 静态类型 Dog     → greet(Dog)

Animal a = new Dog();
a.makeSound();  // 编译器看到 Animal.makeSound()
                // 运行时发现 a 实际是 Dog → 调用 Dog.makeSound()
                // 输出: Woof!

public class CombinedDispatch {
    static class Parent {
        public void foo() { System.out.println("Parent.foo"); }
    }
    static class Child extends Parent {
        @Override
        public void foo() { System.out.println("Child.foo"); }
    }

    public void invoke(Parent p) {  // 重载方法 1
        System.out.print("Parent version → ");
        p.foo();  // 动态分派
    }
    public void invoke(Child c) {   // 重载方法 2
        System.out.print("Child version → ");
        c.foo();  // 动态分派
    }


    public static void main(String[ ] args) {

        CombinedDispatch cd = new CombinedDispatch();
        Parent obj = new Child();

        cd.invoke(obj);      // ①
        cd.invoke((Child) obj); // ②
    }
}

Parent version → Child.foo
Child version → Child.foo

public class BytecodeDemo {
    public static void staticMethod() {}      // invokestatic
    private void privateMethod() {}           // invokespecial
    public void virtualMethod() {}            // invokevirtual


    public static void main(String[ ] args) {

        BytecodeDemo obj = new BytecodeDemo(); // invokespecial (<init>)
        staticMethod();                        // invokestatic
        obj.privateMethod();                   // invokespecial
        obj.virtualMethod();                   // invokevirtual
    }
}

1. 获取操作数栈顶对象的实际类型（通过对象头中的 klass 指针）
2. 在该类型的 vtable 中，按固定索引查找目标方法
3. 如果索引超出子类 vtable 范围（父类新增方法），沿继承链向上查找

Parent 类 vtable:
索引0: Object.toString()     ← 继承自 Object
索引1: Object.hashCode()     ← 继承自 Object
索引2: Parent.foo()

Child extends Parent 的 vtable:
索引0: Object.toString()     ← 未重写，保留
索引1: Object.hashCode()     ← 未重写，保留
索引2: Child.foo()           ← 重写！同索引覆盖
索引3: Child.bar()           ← 新方法，追加

class Animal {
    public Animal reproduce() {
        return new Animal();
    }
}

class Dog extends Animal {
    @Override
    public Dog reproduce() {  // 返回 Dog 而非 Animal —— 协变！
        return new Dog();
    }
}

// 调用方
Dog dog = new Dog();
Dog puppy = dog.reproduce();  // 不需要强制转型！

// 编译后等价于：
class Dog extends Animal {
    @Override
    public Animal reproduce() {   // 编译器自动生成的桥接方法
        return this.reproduce();  // 调用真正返回 Dog 的方法
    }

    public Dog reproduce() {      // 程序员写的"重写"方法（实际在 JVM 层面是新方法）
        return new Dog();
    }
}

class GenericBuilder<T extends GenericBuilder<T>> {
    public T self() { return (T) this; }
}

class CarBuilder extends GenericBuilder<CarBuilder> {
    public CarBuilder color(String color) { /* ... */ return self(); }
    public CarBuilder engine(String engine) { /* ... */ return self(); }
}

// 使用
new CarBuilder()
    .color("red")    // 返回 CarBuilder，可以继续链式调用
    .engine("V8");   // 不需要强制转型

public void foo(int a)           { System.out.println("int"); }
public void foo(Integer a)       { System.out.println("Integer"); }
public void foo(int... a)        { System.out.println("int..."); }

foo(1);  // 第一阶段匹配 foo(int) → 输出 "int"
foo(Integer.valueOf(1));  // 第一阶段匹配 foo(Integer) → 输出 "Integer"

public void foo(CharSequence cs) { System.out.println("CharSequence"); }
public void foo(String s)        { System.out.println("String"); }

foo("hello");  // String 是 CharSequence 的子类型 → foo(String) 更具体 → 输出 "String"
foo((CharSequence) "hello");  // 强制声明为 CharSequence → 输出 "CharSequence"

public void foo(String s, Integer i) { }
public void foo(Integer i, String s) { }

foo("hello", 42);     // 编译通过：匹配第一个
foo(42, "hello");     // 编译通过：匹配第二个
foo(null, null);      // 编译报错！两个方法都适用，无法判断哪个更具体

public void remove(int index)       { System.out.println("remove by index"); }
public void remove(Integer element) { System.out.println("remove by element"); }

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);

list.remove(1);    // 调用哪个？ → remove(int index)，删除索引1的元素
list.remove(Integer.valueOf(1)); // → remove(Integer element)，删除值为1的元素

class Parent<T> {
    public void foo(T t) { System.out.println("Parent.foo"); }
}

class Child extends Parent<String> {
    @Override
    public void foo(String s) { System.out.println("Child.foo"); }
}

class Parent {
    public static void hello() { System.out.println("Parent.hello"); }
}

class Child extends Parent {
    public static void hello() { System.out.println("Child.hello"); }
}

Parent p = new Child();
p.hello();  // 输出 Parent.hello！静态方法依赖引用类型，不依赖实际类型

class Parent {
    private void secret() { System.out.println("Parent.secret"); }
    public void call() { secret(); }
}

class Child extends Parent {
    // 这不是重写！这是 Child 自己的全新方法
    private void secret() { System.out.println("Child.secret"); }
}

new Child().call();  // 输出 Parent.secret！

public void foo(int... nums)   { System.out.println("int..."); }
public void foo(Integer... nums) { System.out.println("Integer..."); }

foo(1, 2, 3);  // 编译报错！int... 和 Integer... 没有"谁更具体"

// 1. 查看字节码确认编译期决策
javap -c -v YourClass.class

// 2. 运行时打调用栈
new Exception("Method dispatch trace").printStackTrace();

// 3. Arthas 动态监控
watch com.example.YourClass yourMethod '{params, returnObj}' -x 3

class A {
    public void foo(A a) { System.out.println("A.foo(A)"); }
}
class B extends A {
    public void foo(A a) { System.out.println("B.foo(A)"); }
    public void foo(B b) { System.out.println("B.foo(B)"); }
}

A obj = new B();
obj.foo(obj);  // ?

class Parent {
    public void foo(String s) { }
}
class Child extends Parent {
    public void foo(String s) { }
    public void foo(Integer i) { }
}

class Parent {
    public void foo(Parent p) { System.out.println("P.foo(P)"); }
}
class Child extends Parent {
    public void foo(Parent p) { System.out.println("C.foo(P)"); }
    public void foo(Child c)  { System.out.println("C.foo(C)"); }
}

Parent a = new Child();
Parent b = new Child();
a.foo(b);  // 输出 "C.foo(P)"

class A {
    public void foo(A a) { System.out.println("A.foo(A)"); }
}
class B extends A {
    public void foo(A a) { System.out.println("B.foo(A)"); }
    public void foo(B b) { System.out.println("B.foo(B)"); }
}

A obj = new B();
obj.foo(obj);  // ?

class Parent {
    public void foo(String s) { }
}
class Child extends Parent {
    public void foo(String s) { }
    public void foo(Integer i) { }
}

new Child().foo((String) null);  // 调用 Child.foo(String)
new Child().foo((Integer) null); // 调用 Child.foo(Integer)

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);

list.remove(1);    // ① 调用 remove(int index)   → 删除索引 1，list → [1, 3]
list.remove(Integer.valueOf(1)); // ② 调用 remove(Object o) → 删除元素 1，list → [2, 3]

public class ReflectionDispatchDemo {
    public void handle(String s) {
        System.out.println("handle(String): " + s);
    }
    public void handle(Object o) {
        System.out.println("handle(Object): " + o);
    }


    public static void main(String[ ] args) throws Exception {

        ReflectionDispatchDemo demo = new ReflectionDispatchDemo();

        // 场景一：正常调用 —— 静态分派，选 handle(String)
        demo.handle("hello");  // 输出: handle(String): hello

        // 场景二：反射调用 —— 绕过静态类型，直接指定方法签名
        // 故意调用 handle(Object)，虽然我们传的是 String
        Method m = ReflectionDispatchDemo.class.getMethod("handle", Object.class);
        m.invoke(demo, "hello");  // 输出: handle(Object): hello
        // ↑ 编译期静态分派被"绕过"了！

        // 场景三：更隐蔽的例子 —— 通过接口引用
        Runnable task = new Runnable() {
            public void run() { System.out.println("anonymous run"); }
        };
        // demo.handle(task) 在编译期会选择 handle(Object)
        // 但如果通过反射精确指定 handle(Runnable) —— 虽然这个方法不存在
        // getMethod("handle", Runnable.class) → NoSuchMethodException!
    }
}

// Spring 框架中类似的场景
// Bean 有一个重载的 init 方法
public class MyService {
    public void init(ApplicationContext ctx) { /* 完整初始化 */ }
    public void init()                      { /* 简单初始化 */ }
}

// 如果 Spring 用 getMethod("init") 去反射调用，拿到的是无参版本
// 但业务可能期望调用有参版本完成完整初始化

// ❌ 禁止
void process(String s);
void process(CharSequence s);  // String is-a CharSequence，容易混淆

// ✅ 允许
void processString(String s);
void processCharSequence(CharSequence s);

// ❌ 禁止 —— int 和 Integer 可通过自动装箱互转
void remove(int index);
void remove(Integer value);

// ✅ 允许 —— 参数类型完全正交
void send(String message);
void send(int code);

// ⚠️ 灰区 —— 建议用不同方法名
void find(String name);
void find(Long id);
// 更好的写法:
void findByName(String name);
void findById(Long id);

// ❌ 禁止
void log(String msg);
void log(String... msgs);  // 单个 String 传参时走第一阶段精确匹配，不调用可变参数版本

// ✅ 允许：明确区分
void log(String msg);
void logBatch(String... msgs);

/**
 * 按索引删除元素。
 * @param index 要删除的元素索引
 * @see #removeElement(Object) 按值删除元素
 */
void removeAt(int index);

/**
 * 按值删除第一个匹配元素。
 * @param element 要删除的元素值
 * @see #removeAt(int) 按索引删除元素
 */
void removeElement(Object element);

interface A {
    default void hello() { System.out.println("A"); }
}
interface B extends A {
    default void hello() { System.out.println("B"); }  // B 比 A 更具体
}
interface C {
    default void hello() { System.out.println("C"); }
}

// 场景1：类优先
class Parent {
    public void hello() { System.out.println("Parent"); }
}
class Child1 extends Parent implements A { }
new Child1().hello();  // 输出 "Parent" —— 类优先

// 场景2：最具体接口优先
class Child2 implements A, B { }
new Child2().hello();  // 输出 "B" —— B extends A，B 更具体

// 场景3：歧义 → 编译报错
class Child3 implements A, C {
    // 必须显式解决冲突：
    @Override
    public void hello() {
        A.super.hello();  // 显式选择 A 的实现
    }
}