Java繼承概念詳細解讀

繼承與合成基本概念

繼承：可以基於已經存在的類構造一個新類。繼承已經存在的類就可以復用這些類的方法和域。在此基礎上，可以添加新的方法和域，從而擴充了類的功能。

合成：在新類裡創建原有的對象稱為合成。這種方式可以重複利用現有的代碼而不更改它的形式。

1.繼承的語法

關鍵字extends表明新類派生於一個已經存在的類。已存在的類稱為父類或基類，新類稱為子類或派生類。例如:

 class Student extends Person {}

類Student繼承了Person，Person類稱為父類或基類，Student類稱為子類或派生類。

2.合成的語法

合成比較簡單，就是在一個類中創建一個已經存在的類。

 class Student { Dog dog;}

上溯造型

1.基本概念

繼承的作用在於代碼的複用。由於繼承意味著父類的所有方法亦可在子類中使用，所以發給父類的消息亦可發給衍生類。如果Person類中有一個eat方法，那麼Student類中也會有這個方法，這意味著Student對像也是Person的一種類型。

 class Person {public void eat() {System.out.println("eat");}static void show(Person p) {p.eat();}}public class Student extends Person{public static void main(String[] args) {Student s = new Student();Person.show(s);// ①}}

【運行結果】：

eat

在Person中定義的show方法是用來接收Person句柄的，但是在①處接收的卻是Student對象的引用。這是因為Student對像也是Person對象。在show方法中，傳入的句柄(對象的引用)可以是Person對像以及Person的衍生類對象。這種將Student句柄轉換成Person句柄的行為成為上溯造型。

2.為什麼要上溯造型

為什麼在調用eat是要有意忽略調用它的對像類型呢？如果讓show方法簡單地獲取Student句柄似乎更加直觀易懂，但是那樣會使衍生自Person類的每一個新類都要實現專屬自己的show方法：

 class Value {private int count = 1;private Value(int count) {this.count = count;}public static final Value v1 = new Value(1), v2 = new Value(2), v3 = new Value(3);}class Person {public void eat(Value v) {System.out.println("Person.eat()");}}class Teacher extends Person {public void eat(Value v) {System.out.println("Teacher.eat()");}}class Student extends Person {public void eat(Value v) {System.out.println("Student.eat()");}}public class UpcastingDemo {public static void show(Student s) {s.eat(Value.v1);}public static void show(Teacher t) {t.eat(Value.v1);}public static void show(Person p) {p.eat(Value.v1);}public static void main(String[] args) {Student s = new Student();Teacher t = new Teacher();Person p = new Person();show(s);show(t);show(p);}}

這種做法一個很明顯的缺陷就是必須為每一個Person類的衍生類定義與之緊密相關的方法，產生了很多重複的代碼。另一方面，對於如果忘記了方法的重載也不會報錯。上例中的三個show方法完全可以合併為一個：

 public static void show(Person p) { p.eat(Value.v1);}

動態綁定

當執行show(s)時,輸出結果是Student.eat()，這確實是希望得到的結果，但是似乎沒有按照我們希望的形式來執行，再來看一下show方法：

 public static void show(Person p) { p.eat(Value.v1);}

它接收的是Person句柄，當執行show(s)時，它是如何知道Person句柄指向的是一個Student對象而不是Teacher對象呢？編譯器是無從得知的，這涉及到接下來要說明的綁定問題。

1.方法調用的綁定

將一個方法同一個方法主體連接在一起就稱為綁定(Binding)。若在運行運行前執行綁定，就稱為“早期綁定”。上面的例子中，在只有一個Person句柄的情況下，編譯器不知道具體調用哪個方法。 Java實現了一種方法調用機制，可在運行期間判斷對象的類型，然後調用相應的方法，這種在運行期間進行，以對象的類型為基礎的綁定稱為動態綁定。除非一個方法被聲明為final，Java中的所有方法都是動態綁定的。

用一張圖表示上溯造型的繼承關係：

用代碼概括為：

Shapes=newShape();

按照繼承關係，將創建的Circle對象句柄賦給一個Shape是合法的，因為Circle屬於Shape的一種。

當調用其中一個基礎類方法時：

Shapes=newShape();

此時，調用的是Circle.draw(),這是由於動態綁定的原因。

 class Person {void eat() {}void speak() {}}class Boy extends Person {void eat() {System.out.println("Boy.eat()");}void speak() {System.out.println("Boy.speak()");}}class Girl extends Person {void eat() {System.out.println("Girl.eat()");}void speak() {System.out.println("Girl.speak()");}}public class Persons {public static Person randPerson() {switch ((int)(Math.random() * 2)) {default: case 0: return new Boy();case 1: return new Girl();}}public static void main(String[] args) {Person[] p = new Person[4];for (int i = 0; i < p.length; i++) {p[i] = randPerson();// 隨機生成Boy或Girl}for (int i = 0; i < p.length; i++) {p[i].eat();}}}

對所有從Person衍生出來的類，Person建立了一個通用接口，所有衍生的類都有eat和speak兩種行為。衍生類覆蓋了這些定義，重新定義了這兩種行為。在主類中，randPerson隨機選擇Person對象的句柄。 **上訴造型是在return語句裡發生的。 **return語句取得一個Boy或Girl的句柄並將其作為Person類型返回，此時並不知道具體是什麼類型，只知道是Person對象句柄。在main方法中調用randPerson方法為數組填入Person對象，但不知具體情況。當調用數組每個元素的eat方法時，動態綁定的作用就是執行對象的重新定義了的方法。

然而，動態綁定是有前提的，綁定的方法必須存在於基類中，否則無法編譯通過。

 class Person {void eat() {System.out.println("Person.eat()");}}class Boy extends Person {void eat() {System.out.println("Boy.eat()");}void speak() {System.out.println("Boy.speak()");}}public class Persons {public static void main(String[] args) {Person p = new Boy();p.eat();p.speak();// The method speak() is undefined for the type Person}}

如果子類中沒有定義覆蓋方法，則會調用父類中的方法：

 class Person {void eat() {System.out.println("Person.eat()");}}class Boy extends Person {}public class Persons {public static void main(String[] args) {Person p = new Boy();p.eat();}}

【運行結果】:

Person.eat()

2.靜態方法的綁定

將上面的方法都加上static關鍵字，變成靜態方法：

 class Person {static void eat() {System.out.println("Person.eat()");}static void speak() {System.out.println("Person.speak()");}}class Boy extends Person {static void eat() {System.out.println("Boy.eat()");}static void speak() {System.out.println("Boy.speak()");}}class Girl extends Person {static void eat() {System.out.println("Girl.eat()");}static void speak() {System.out.println("Girl.speak()");}}public class Persons {public static Person randPerson() {switch ((int)(Math.random() * 2)) {default: case 0: return new Boy();case 1: return new Girl();}}public static void main(String[] args) {Person[] p = new Person[4];for (int i = 0; i < p.length; i++) {p[i] = randPerson();// 隨機生成Boy或Girl}for (int i = 0; i < p.length; i++) {p[i].eat();}}}

【運行結果】：
Person.eat()
Person.eat()
Person.eat()
Person.eat()
觀察結果，對於靜態方法而言，不管父類引用指向的什麼子類對象，調用的都是父類的方法。

助記口訣

- 靜態方法:靜態方法看父類
- 非靜態方法：非靜態方法看子類

總結

以上就是本文關於Java繼承概念詳細解讀的全部內容，希望對大家有所幫助。感興趣的朋友可以繼續參閱本站其他相關專題，如有不足之處，歡迎留言指出。感謝朋友們對本站的支持！