Java之繼承、抽象類、介面篇

一、繼承（extends）

什麼是繼承？

繼承是對現實生活中的"分類"概念的一種模擬。

獅子擁有動物的一切基本特性，但同時又擁有自己的獨特的特性，這就是"繼承"關係的重要特性：通常簡稱為"IS_A"關係，UML類圖可以這麼表示：

繼承的語法

class 子類名 extends 父類名 {

    ……

}

註意：

    父類（parent class）和超類（super class）：通常指直接上級；

    基類（base class）：通常指包括直接上級在內的"上級的上級"；

例如：

    子類自動擁有父類聲明為public和protected的成員，這就是繼承特性的體現之一。

繼承條件下類的訪問許可權：

    public:外界可自由訪問

    private:外界不可訪問

    protected:同一包中的子類都可以訪問，另一包中的子類（派生於同一個父類）也可以訪問

    default:如果不指明任何許可權，則預設同一包中的類可以訪問

繼承條件下的構造方法調用

首先，看這段代碼有什麼發現？

 1 class Grandparent {
 2 
 3     public Grandparent() {
 4         System.out.println("GrandParent Created.");
 5     }
 6 
 7     public Grandparent(String string) {
 8         System.out.println("GrandParent Created.String:" + string);
 9     }
10 }
11 
12 class Parent extends Grandparent {
13 
14     public Parent() {
15         //super("Hello.Grandparent.");
16         System.out.println("Parent Created");
17        // super("Hello.Grandparent.");
18     }
19 }
20 
21 class Child extends Parent {
22 
23     public Child() {
24         System.out.println("Child Created");
25     }
26 }
27 
28 public class TestInherits {
29 
30     public static void main(String args[]) {
31         Child c = new Child();
32     }
33 }

觀察輸出，可以得出以下結論：

    1).在繼承父類的時候預設調用父類的無參構造函數，如果父類裡面並沒有無參的構造函數，那麼這裡子類的無參構造函數就會報錯，如果想要調用有參構造函數的話就要用到super了，顯示調用GrandParent的含參構造函數，而且必須將super()放在子類構造函數里第一行。

    2).在初始化子類之前顯示初始化父類，爸爸出來才有兒子，沒有爸爸兒子不可能出來哈。

    3).在子類中調用父類的屬性，super. 和 this. 的形式區分於父類、子類的成員。

不允許繼承的類

final class 類名 {

}

1)以final聲明的方法不允許覆蓋。

2)以final聲明的變數不允許更改。

3)利用final,可以設計出一種特殊的"只讀"的"不可變類"。

"不可變類"？

    創建"不可變的類"的對象後，此對象的屬性不可改，而且也無法從此類派生出新子類。String就是一個典型的例子。

    用處：可以方便和安全地用於多線程環境中；

         訪問它們可以不用加鎖，因而能提供較高的性能。

實例：Address.java

 1 public final class Address
 2 {
 3     private final String detail;
 4     private final String postCode;
 5 
 6     //在構造方法里初始化兩個實例屬性
 7     public Address()
 8     {
 9         this.detail = "";
10         this.postCode = "";
11 
12     }
13     public Address(String detail , String postCode)
14     {
15         this.detail = detail;
16         this.postCode = postCode;
17     }
18     //僅為兩個實例屬性提供getter方法
19     public String getDetail()
20     {
21          return this.detail;
22     }
23 
24     public String getPostCode()
25     {
26          return this.postCode;
27     }
28     //重寫equals方法，判斷兩個對象是否相等。
29     public boolean equals(Object obj)
30     {
31         if (obj instanceof Address)
32         {
33             Address ad = (Address)obj;
34             if (this.getDetail().equals(ad.getDetail()) && this.getPostCode().equals(ad.getPostCode()))
35             {
36                 return true;
37             }
38         }
39         return false;
40     }
41     public int hashCode()
42     {
43         return detail.hashCode() + postCode.hashCode();
44     }
45 }

子類與父類方法間的關係

子類與弗雷各自定義的方法之間，可以出現以下三種情況：

    擴充（Extends）：子類定義的方法父類沒有同名。

    覆蓋/重寫（Override）：子類父類定義了完全一樣的方法 ------》需要註意覆蓋時要遵守的"覆蓋原則"，如：靜態的方法不允許覆蓋等等。

    重載（Overloads）：子類有父類的同名方法，但兩者的參數類型或參數數目不一樣。

頂層基類Object

在Java中，所有的類都派生自Object，此類定義了一下方法：

神奇的"+"號

看這段代碼：

註意最後一句，一個子串和一個對象"相加"，得到一下結果：

為什麼呢?

Fruit類覆蓋了Object類中的toString方法。

結論：

    在"+"運算中，當任何一個對象與一個String對象，連接時，會隱式地調用其toString()方法，預設情況下，此方法返回"類名@+hashCode"。為了返回有意義的信息，子類可以重寫toString()方法。

Java"方法覆蓋"的語法規則

1. 覆蓋方法的允許範圍不能小於原方法。
2. 覆蓋方法所拋出的異常不能比原方法更多。
3. 聲明為final方法不允許覆蓋。
   1. 例如，Object的getClass()方法不能覆蓋。
4. 不能覆蓋靜態方法。

二、抽象（abstract）和介面（interface）

抽象類和抽象方法

1. 有abstract修飾的類稱為"抽象類"，它只定義了什麼方法應該存在，不能創建對象，必須派生出一個子類，併在子類中實現其未實現的方法之後，才能使用new關鍵字創建對象。
2. 在方法前加上abstract就形成抽象方法，只有方法聲明，沒有實現代碼。
   1. 示例：
3. 一個抽象類中可以包含非抽象方法和成員變數。包含抽象方法的類一定是抽象類，但是抽象類中的方法不一定是抽象方法。

抽象類的三種"類型"

1. 直接定義了一個抽象方法
2. 繼承了一個抽象父類，但沒有完全實現父類包含的抽象方法
3. 實現了一個介面，但沒有完全實現此介面所包容的抽象方法。

註意：

1. 從抽象類繼承的子類必須實現父類的所有抽象方法，否則，它仍然是抽象類。
2. 抽象類不能創建對象，一般用它來引用子類對象。
   1. 實例：
      1. Person p;
      2. p = new Employee();
   2. 以下模式總是成立的：
      1. 抽象類 抽象類變數 = new 派生自抽象類的具體子類();

面向對象程式設計中，為什麼要進入"介面"？

    C++裡面的繼承是多重繼承，但是Java裡面只能是單個繼承，為了彌補這些，就引入介面的概念。

    如果想繼承其他類，就把其他類定義成介面（其實也是特殊的類），關鍵字interface用來定義介面，關鍵字implements用於介面繼承，介面可以繼承多個，因此可以用介面實現多重繼承。

Java中"介面"的語法特性

1. 定義一個介面，採用關鍵字interface，實現一個介面，採用關鍵字implements，繼承一個或多個介面，多個介面之間用"逗號"連接。
2. 介面的成員函數自動成為public的，數據成員自動成為static和final的。
3. 如果介面不聲明為public的，則自動變為package。
4. 一個類可以同時實現多個介面。

介面的使用

介面類型 介面類型的變數 = new 實現了藉口的具體類型();

介面的擴充

可以通過繼承介面擴充已有介面，並形成一個新的介面。

示例：

實現子介面的類，必須實現"父""子"介面所定義的所有方法，才能被實例化（即new出一個對象）。

利用介面定義常量

1. 只要一個類聲明實現了這個介面，就可以直接使用這些常量名。
2. 在實際開發中，這種編程方式非常常見。
3. 註意：定義在介面中的常量必須被初始化。

介面與抽象類的區別

1. 抽象類是一個不完全的類，而介面只是表明類應該具有哪些"外部"特征，不涉及任何實現細節。
2. 介面基本上不具備繼承的任何具體特點，它僅僅承諾了外界能夠調用的方法。
3. 一個類一次可以實現若幹個介面，但一個類只能繼承一個父類。