電腦程式的思維邏輯 (16) - 繼承的細節

標籤：

上節我們介紹了繼承和多態的基本概念，基本概念是比較簡單的，子類繼承父類，自動擁有父類的屬性和行為，並可擴充屬性和行為，同時，可重寫父類的方法以修改行為。

但繼承和多態概念還有一些相關的細節，本節就來探討這些細節，具體包括：

• 構造方法
• 重名與靜態繫結
• 重載和重寫
• 父子類型轉換
• 繼承存取權限 (protected)
• 可見度重寫
• 防止繼承 (final)

下面我們逐個來解釋。

構造方法

super

上節我們說過，子類可以通過super(...)調用父類的構造方法，如果子類沒有通過super(...)調用，則會自動調動父類的預設構造方法，那如果父類沒有預設構造方法呢？如下例所示：

public class Base {    private String member;    public Base(String member){        this.member = member;    }}

這個類只有一個帶參數的構造方法，沒有預設構造方法。這個時候，它的任何子類都必須在構造方法中通過super(...)調用Base的帶參數構造方法，如下所示，否則，Java會提示編譯錯誤。

public class Child extends Base {    public Child(String member) {        super(member);    }}

構造方法調用重寫方法

如果在父類構造方法中調用了可被重寫的方法，則可能會出現意想不到的結果，我們來看個例子：

這是基類代碼：

public class Base {    public Base(){        test();    }        public void test(){    }}

構造方法調用了test()。這是子類代碼：

public class Child extends Base {    private int a = 123;        public Child(){    }        public void test(){        System.out.println(a);    }}

子類有一個執行個體變數a，初始賦值為123，重寫了test方法，輸出a的值。看下使用的代碼：

public static void main(String[] args){    Child c = new Child();    c.test();}

輸出結果是：

0123

第一次輸出為0，第二次為123。第一行為什麼是0呢？第一次輸出是在new過程中輸出的，在new過程中，首先是初始化父類，父類構造方法調用 test()，test被子類重寫了，就會調用子類的test()方法，子類方法訪問子類執行個體變數a，而這個時候子類的執行個體變數的指派陳述式和構造方法還沒 有執行，所以輸出的是其預設值0。

像這樣，在父類構造方法中調用可被子類重寫的方法，是一種不好的實踐，容易引起混淆，應該只調用private的方法。

重名與靜態繫結

上節我們說到，子類可以重寫父類非private的方法，當調用的時候，會動態綁定，執行子類的方法。那執行個體變數、靜態方法、和靜態變數呢？它們可以重名嗎？如果重名，訪問的是哪一個呢？

重名是可以的，重名後實際上有兩個變數或方法。對於private變數和方法，它們只能在類內被訪問，訪問的也永遠是當前類的，即在子類中，訪問的是子類的，在父類中，訪問的父類的，它們只是碰巧名字一樣而已，沒有任何關係。

但對於public變數和方法，則要看如何訪問它，在類內訪問的是當前類的，但子類可以通過super.明確指定訪問父類的。在類外，則要看訪問變數的靜態類型，靜態類型是父類，則訪問父類的變數和方法，靜態類型是子類，則訪問的是子類的變數和方法。我們來看個例子：

這是基類代碼：

public class Base {    public static String s = "static_base";    public String m = "base";        public static void staticTest(){        System.out.println("base static: "+s);    }}

定義了一個public靜態變數s、一個public執行個體變數m、一個靜態方法staticTest。

這是子類代碼：

public class Child extends Base {    public static String s = "child_base";    public String m = "child";        public static void staticTest(){        System.out.println("child static: "+s);    }}

子類定義了和父類重名的變數和方法。對於一個子類對象，它就有了兩份變數和方法，在子類內部訪問的時候，訪問的是子類的，或者說，子類變數和方法隱藏了父類對應的變數和方法，下面看一下外部存取的代碼：

public static void main(String[] args) {    Child c = new Child();    Base b = c;        System.out.println(b.s);    System.out.println(b.m);    b.staticTest();        System.out.println(c.s);    System.out.println(c.m);    c.staticTest();}

以上代碼建立了一個子類對象，然後將對象分別賦值給了子類引用變數c和父類引用變數b，然後通過b和c分別引用變數和方法。這裡需要說明的是，靜態變數和靜態方法一般通過類名直接存取，但也可以通過類的對象訪問。程式輸出為：

static_basebasebase static: static_basechild_basechildchild static: child_base 

當通過b (靜態類型Base) 訪問時，訪問的是Base的變數和方法，當通過c (靜態類型Child)訪問時，訪問的是Child的變數和方法，這稱之為靜態繫結，即訪問綁定到變數的靜態類型，靜態繫結在程式編譯階段即可決定，而動態綁定則要等到程式運行時。執行個體變數、靜態變數、靜態方法、private方法，都是靜態繫結的。

重載和重寫

重載是指方法名稱相同但參數簽名不同（參數個數或類型或順序不同），重寫是指子類重寫父類相同參數簽名的方法。對一個函數調用而言，可能有多個匹配的方法，有時候選擇哪一個並不是那麼明顯，我們來看個例子：

這裡基類代碼：

public class Base {    public int sum(int a, int b){        System.out.println("base_int_int");        return a+b;    }}

它定義了方法sum，下面是子類代碼：

public class Child extends Base {    public long sum(long a, long b){        System.out.println("child_long_long");        return a+b;    }}

以下是調用的代碼：

public static void main(String[] args){    Child c = new Child();    int a = 2;    int b = 3;    c.sum(a, b);}

這個調用的是哪個sum方法呢？每個sum方法都是相容的，int類型可以自動轉型為long，當只有一個方法的時候，那個方法就會被調用。但現在有多個方法可用，子類的sum方法參數類型雖然不完全符合但是是相容的，父類的sum方法參數類型是完全符合的。程式輸出為：

base_int_int

父類類型完全符合的方法被調用了。如果父類代碼改成下面這樣呢？

public class Base {    public long sum(int a, long b){        System.out.println("base_int_long");        return a+b;    }}

父類方法類型也不完全符合了。程式輸出為：

base_int_long

調用的還是父類的方法。父類和子類的兩個方法的類型都不完全符合，為什麼調用父類的呢？因為父類的更匹配一些。現在修改一下子類代碼，更改為：

public class Child extends Base {    public long sum(int a, long b){        System.out.println("child_int_long");        return a+b;    }}

程式輸出變為了：

child_int_long

終於調用了子類的方法。可以看出，當有多個重名函數的時候，在決定要調用哪個函數的過程中，首先是按照參數類型進行匹配的，換句話說，尋找在所有重載版本中最匹配的，然後才看變數的動態類型，進行動態綁定。

父子類型轉換

之前我們說過，子類型的對象可以賦值給父類型的引用變數，這叫向上轉型，那父類型的變數可以賦值給子類型的變數嗎？或者說可以向下轉型嗎？文法上可以進行強制類型轉換，但不一定能轉換成功。我們以上面的例子來樣本：

Base b = new Child();Child c = (Child)b;

Child c = (Child)b就是將變數b的類型強制轉換為Child並賦值為c，這是沒有問題的，因為b的動態類型就是Child，但下面代碼是不行的：

Base b = new Base();Child c = (Child)b;

文法上Java不會報錯，但運行時會拋出錯誤，錯誤為類型轉換異常。

一個父類的變數，能不能轉換為一個子類的變數，取決於這個父類變數的動態類型（即引用的物件類型）是不是這個子類或這個子類的子類。

給定一個父類的變數，能不能知道它到底是不是某個子類的對象，從而安全的進行類型轉換呢？答案是可以，通過instanceof關鍵字，看下面代碼：

public boolean canCast(Base b){    return b instanceof Child;}

這個函數返回Base類型變數是否可以轉換為Child類型，instanceof前面是變數，後面是類，傳回值是boolean值，表示變數引用的對象是不是該類或其子類的對象。

protected

變數和函數有public/private修飾符，public表示外部可以訪問，private表示只能內部使用，還有一種可見度介於中間的修飾符protected，表示雖然不能被外部任意訪問，但可被子類訪問。另外，在Java中，protected還表示可被同一個包中的其他類訪問，不管其他類是不是該類的子類，後續章節我們再討論包。

我們來看個例子，這是基類代碼：

public class Base {    protected  int currentStep;        protected void step1(){    }        protected void step2(){            }        public void action(){        this.currentStep = 1;        step1();        this.currentStep = 2;        step2();    }}

action() 表示對外提供的行為，內部有兩個步驟step1()和step2()，使用currentStep變數表示當前進行到了哪個步驟，step1、step2 和currentStep是protected的，子類一般不重寫action，而只重寫step1和step2，同時，子類可以直接存取 currentStep查看進行到了哪一步。子類的代碼是：

public class Child extends Base {    protected void step1(){        System.out.println("child step "                +this.currentStep);    }        protected void step2(){            System.out.println("child step "                +this.currentStep);    }}

使用Child的代碼是：

public static void main(String[] args){    Child c = new Child();    c.action();}

輸出為：

child step 1child step 2

基類定義了表示對外行為的方法action，並定義了可以被子類重寫的兩個步驟step1和step2，以及被子類查看的變數currentStep，子類通過重寫protected方法step1和step2來修改對外的行為。

這種思路和設計在設計模式中被稱之為模板方法，action方法就是一個模板方法，它定義了實現的模板，而具體實現則由子類提供。模板方法在很多架構中有廣泛的應用，這是使用protected的一個常用情境。關於更多設計模式的內容我們暫不介紹。

可見度重寫

重寫方法時，一般並不會修改方法的可見度。但我們還是要說明一點，重寫時，子類方法不能降低父類方法的可見度，不能降低是指，父類如果是public，則子類也必須是public，父類如果是protected，子類可以是protected，也可以是public，即子類可以升級父類方法的可見度但不能降低。如下所示：

基類代碼為：

public class Base {    protected void protect(){    }        public void open(){            }}

子類代碼為：

public class Child extends Base {    //以下是不允許的的，會有編譯錯誤//    private void protect(){//    }        //以下是不允許的，會有編譯錯誤//    protected void open(){        //    }        public void protect(){            }}

為什麼要這樣規定呢？繼承反映的是"is-a"的關係，即子類對象也屬於父類，子類必須支援父類所有對外的行為，將可見度降低就會減少子類對外的行為，從而破壞"is-a"的關係，但子類可以增加父類的行為，所以提升可見度是沒有問題的。

防止繼承 (final)

上節我們提到繼承是把雙刃劍，具體原因我們後續章節解說，帶來的影響就是，有的時候我們不希望父類方法被子類重寫，有的時候甚至不希望類被繼承，實現這個的方法就是final關鍵字。之前我們提過final可以修飾變數，這是final的另一個用法。

一個Java類，預設情況下都是可以被繼承的，但加了final關鍵字之後就不能被繼承了，如下所示：

public final class Base {   //....}

一個非final的類，其中的public/protected執行個體方法預設情況下都是可以被重寫的，但加了final關鍵字後就不能被重寫了，如下所示：

public class Base {    public final void test(){        System.out.println("不能被重寫");    }} 

小結

本節我們討論了Java繼承概念引入的一些細節，有些細節可能平時遇到的比較少，但我們還是需要對它們有一個比較好的瞭解，包括構造方法的一些細節，變數和方法的重名，父子類型轉換，protected，可見度重寫，final等。

但還有些重要的地方我們沒有討論，比如，建立子類對象的具體過程？動態綁定是如何?的？讓我們下節來探索繼承實現的基本原理。

----------------

未完待續，查看最新文章，敬請關注公眾號“老馬說編程”(掃描下方二維碼)，從入門到進階，深入淺出，老馬和你一起探索Java編程及電腦技術的本質。原創文章，保留所有著作權。

電腦程式的思維邏輯 (16) - 繼承的細節