Java 重寫與重載調用機制深度解析

代碼一分析

class A { 
    public String show(D obj) { return "A and D"; }
    public String show(A obj) { return "A and A"; }
}
class B extends A { 
    public String show(B obj) { return "B and B"; } // 重載
    public String show(A obj) { return "B and A"; } // 重寫
}
class C extends B {}
class D extends B {}

A a2 = new B();
B b = new B();
C c = new C();
D d = new D();

System.out.println(a2.show(b)); // ①
System.out.println(a2.show(c)); // ②

運行結果

① 輸出：B and A
② 輸出：B and A

詳細解析

1. 編譯時期靜態綁定（重載）：`a2` 編譯類型是 `A`，`A` 類中有 `show(A)` 和 `show(D)`。實參 `b` 類型是 `B`，`B` 是 `A` 的子類，匹配 `show(A obj)`（向上轉型）。不會匹配 B 類的 `show(B)`，因為重載由引用類型決定。
2. 運行時期動態綁定（重寫）：確定調用 `show(A)` 後，`a2` 實際指向 `B` 對象，`B` 重寫了 `show(A)`，故執行 `B.show(A)` → "B and A"。
3. 同理 `c` 類型 `C` 繼承 `B`，也是 `A` 子類，匹配 `show(A)`，動態分派到 `B.show(A)`。

代碼二分析

class A {
    public void MethodA() {}        // 普通方法
    public virtual void MethodB() {} // 虛方法 (C# 語法)
}
class B extends A {
    public new void MethodA() {}     // 隱藏
    public override void MethodB() {} // 重寫
}

A a = new B();
a.MethodA(); // ③
a.MethodB(); // ④

運行結果

③ 調用 A.MethodA
④ 調用 B.MethodB

核心區別

Java vs C# 關鍵差異

• Java：實例方法默認虛方法（動態分派），`final`/`private`/`static` 為靜態綁定。無 `new` 隱藏語法，子類同名方法自動重寫。
• C#：方法默認非虛（靜態綁定），需 `virtual` 開啟多態，`override` 重寫，`new` 顯式隱藏。

Java 等效驗證代碼

abstract class E {
    public void MethodA() { System.out.println("A-->MethodA"); }
    public abstract void MethodB(); // 強制子類實現，類似 virtual
}
class F extends E {
    @Override public void MethodA() { System.out.println("B-->MethodA"); }
    @Override public void MethodB() { System.out.println("B-->MethodB"); }
}

E e = new F();
e.MethodA(); // 輸出: B-->MethodA (Java 動態分派)
e.MethodB(); // 輸出: B-->MethodB

總結

1. 重載：編譯期靜態綁定，看引用類型和參數列表
2. 重寫：運行期動態綁定，看實際對象類型
3. Java 實例方法默認可重寫（動態分派），C# 需顯式 `virtual`
4. `a2.show(b)` 中 `a2` 為 `A` 類型，匹配 `A.show(A)`，執行 `B.show(A)`