如果你認為你對java的重載和重寫已經很了解了，那么我想通過下面的例子你可能會感到懷疑人生了。如果你能完全回答對下面的題目，那我覺得你真的非常非常牛X了。

[[349661]]

單一調度

class Parent { 
  void print(String a) { log.info("Parent - String"); } 
  void print(Object a) { log.info("Parent - Object"); } 
} 
  
class Child extends Parent { 
  void print(String a) { log.info("Child - String"); } 
  void print(Object a) { log.info("Child - Object"); } 
} 

下面將會打印什么?

String string = ""; 
Object stringstringObject = string; 
  
// 打印什么？ 
Child child = new Child(); 
child.print(string); 
child.print(stringObject); 
  
Parent parent = new Child(); 
parent.print(string); 
parent.print(stringObject); 

答案：

child.print(string);        // 打印: "Child - String" 
child.print(stringObject);  // 打印: "Child - Object" 
  
parent.print(string);       // 打印: "Child - String" 
parent.print(stringObject); // 打印: "Child - Object" 

print(string)和 parent.print(string)是 Java 面向對象程序設計的教科書示例。被調用的方法取決于實際的實例類型，而不是聲明的實例類型。例如，無論你將變量定義為 Child 還是 Parent，因為實際的實例類型是 Child，都將調用 Child: : print。

第二組則更為復雜，因為都是完全相同的字符串。唯一的區別是字符串被聲明為 String，而 stringObject 被聲明為 Object。在處理方法參數時，重要的是參數的聲明類型，而不是它的實際類型。即使實際參數類型是 String，也會調用 print (Object)

隱式重寫

class Parent { 
  void print(Object a) { log.info("Parent - Object"); } 
} 
  
class Child extends Parent { 
  void print(String a) { log.info("Child - String"); } 
} 

打印什么?

String string = ""; 
Parent parent = new Child(); 
parent.print(string); 

答案：

parent.print(string);  // 打印: "Parent - Object" 

實際的實例類型是 Child，聲明的參數類型是 String，我們確實有一個為 Child: : print (String)定義的方法。實際上，這正是在前一個示例中調用 parent.print (string)時選擇的內容。但是，這并不是在這里調用的方法。

在檢查子類重寫之前，Java 似乎首先選擇要調用哪個方法。在這種情況下，聲明的實例類型是 Parent，Parent 中唯一匹配的方法是 Parent: : print (Object)。然后，當 Java 檢查 Parent: : print (Object)的任何潛在重寫時，它沒有找到任何重寫，因此這就是執行的方法。

顯式重寫

class Parent { 
  void print(Object a) { log.info("Parent - Object!"); } 
  void print(String a) { throw new RuntimeException(); } 
} 
  
class Child extends Parent { 
  void print(String a) { log.info("Child - String!"); } 
} 

打印什么?

String string = ""; 
Parent parent = new Child(); 
parent.print(string); 

答案:

parent.print(string);  // 打印: "Child - String!" 

這個示例與前面的示例之間的唯一區別是，我們添加了一個新的 Parent: : print (String)方法。這個方法實際上從來沒有被執行過——如果它運行了，它會拋出一個異常!然而，它的存在使 Java 執行了一個不同的方法。

在計算 Parent.print (String)時，運行時現在找到一個匹配的 Parent: : print (String)方法，然后看到這個方法被 Child: : print (String)重寫。

模糊參數

class Foo { 
  void print(Cloneable a) { log.info("I am cloneable!"); } 
  void print(Map a) { log.info("I am Map!"); } 
} 

下面打印的是什么?

HashMap cloneableMap = new HashMap(); 
Cloneable cloneable = cloneableMap; 
Map map = cloneableMap; 
  
// What gets printed? 
Foo foo = new Foo(); 
foo.print(map); 
foo.print(cloneable); 
foo.print(cloneableMap); 

答案：

foo.print(map);           // 打印: "I am Map!" 
foo.print(cloneable);     // 打印: "I am cloneable!" 
foo.print(cloneableMap);  // 編譯不通過 

與單一調度示例類似，這里重要的是參數的聲明類型，而不是實際類型。另外，如果有多個方法對于給定的參數同樣有效，Java會拋出一個編譯錯誤，并強制你指定應該調用哪個方法。

多重繼承-接口

interface Father { 
  default void print() { log.info("I am Father!"); } 
} 
  
interface Mother { 
  default void print() { log.info("I am Mother!"); } 
} 
  
class Child implements Father, Mother {} 

下面打印的是什么?

new Child().print(); 

與前面的示例類似，這個示例也編譯不通過。具體地說，Child 的類定義本身將無法編譯，因為在 Father 和 Mother 中存在沖突的缺省方法。你需要修改 Child 類指定 Child: : print 的行為。

多重繼承-類和接口

class ParentClass { 
  void print() { log.info("I am a class!"); } 
} 
  
interface ParentInterface { 
  default void print() { log.info("I am an interface!"); } 
} 
  
class Child extends ParentClass implements ParentInterface {} 

打印什么?

new Child().print(); 

答案：

new Child().print();  // 打印: "I am a class!" 

如果類和接口之間存在繼承沖突，那么類方法優先。

傳遞性重寫

class Parent { 
  void print() { foo(); } 
  void foo() { log.info("I am Parent!"); } 
} 
  
class Child extends Parent { 
  void foo() { log.info("I am Child!"); } 
} 

打印什么?

new Child().print(); 

答案：

new Child().print();  // 打印: "I am Child!" 

重寫方法甚至對傳遞調用也會生效，閱讀 Parent 類的人可能認為 Parent: : print 總是會調用 Parent: : foo。但是如果該方法被重寫，那么 Parent: : print 將調用重寫后的 foo ()版本。

私有重寫

class Parent { 
  void print() { foo(); } 
  private void foo() { log.info("I am Parent!"); } 
} 
  
class Child extends Parent { 
  void foo() { log.info("I am Child!"); } 
} 

打印什么?

new Child().print(); 

答案：

new Child().print();  // 打印: "I am Parent!" 

除了一點不同之外，這個與前一個例子完全相同?，F在將 Parent.foo()聲明為 private。因此，當 Parent.print()調用 foo()時，不管子類中是否存在 foo()的其他實現，也不管調用 print()的實例的實際類型如何。

靜態重寫

class Parent { 
  static void print() { log.info("I am Parent!"); } 
} 
  
class Child extends Parent { 
  static void print() { log.info("I am Child!"); } 
} 

打印什么?

Child child = new Child(); 
Parent parent = child; 
  
parent.print(); 
child.print(); 

答案:

parent.print(); // 打印: "I am Parent!" 
child.print();  // 打印: "I am Child!" 

Java 不允許重寫靜態方法。如果在父類和子類中定義了相同的靜態方法，那么實例的實際類型根本不重要。只有聲明的類型用于確定調用兩個方法中的哪一個。

這是使用@override注解標記所有重寫方法的另一個原因。在上面的例子中，在向 Child: : print 添加注解時，你會得到一個編譯錯誤，告訴你由于方法是靜態的，因此無法重寫該方法。

靜態鏈接

class Parent { 
  void print() { staticMethod(); instanceMethod(); } 
  static void staticMethod() { log.info("Parent::staticMethod"); } 
  void instanceMethod() { log.info("Parent::instanceMethod"); } 
} 
  
class Child extends Parent { 
  static void staticMethod() { log.info("Child::staticMethod"); } 
  void instanceMethod() { log.info("Child::instanceMethod"); } 
} 

打印什么?

Child child = new Child(); 
child.print(); 

答案：

Parent::staticMethod 
Child::instanceMethod 

這是我們之前討論過的一些不同概念的組合。例如，即使調用方位于父方法中，重寫也會生效。但是，對于靜態方法，即使變量的聲明類型是 Child，也要調用 Parent: : staticMethod，因為有中間 print ()方法。

總結

如果說有什么值得注意的地方，那就是繼承非常非常棘手，而且很容易出錯。