「萬字圖文」史上最姨母級Java繼承詳解

華為雲開發者社群發表於2021-07-12

Java繼承

摘要：繼承是物件導向軟體技術中的一個概念。它使得複用以前的程式碼非常容易，能夠大大縮短開發週期，降低開發費用。

本文分享自華為雲社群《「萬字圖文」史上最姨母級Java繼承詳解丨【奔跑吧！JAVA】》，原文作者： bigsai 。

課程導學

在Java課堂中，所有老師不得不提到物件導向（Object Oriented），而在談到物件導向的時候，又不得不提到物件導向的三大特徵：封裝、繼承、多型。三大特徵緊密聯絡而又有區別，本課程就帶你學習Java的繼承。

你可能不知道繼承到底有什麼用，但你大概率曾有過這樣的經歷：寫Java專案/作業時候建立很多相似的類，類中也有很多相同的方法，做了很多重複的工作量，感覺很臃腫。而合理使用繼承就能大大減少重複程式碼，提高程式碼複用性。

繼承的初相識

學習繼承，肯定是先從廣的概念瞭解繼承是什麼以及其作用，然後才從細的方面學習繼承的具體實現細節，本文就是帶你先快速瞭解和理解繼承的重要概念。

什麼是繼承

繼承（英語：inheritance）是物件導向軟體技術中的一個概念。它使得複用以前的程式碼非常容易，能夠大大縮短開發週期，降低開發費用。

Java語言是非常典型的物件導向的語言，在Java語言中繼承就是子類繼承父類的屬性和方法，使得子類物件（例項）具有父類的屬性和方法，或子類從父類繼承方法，使得子類具有父類相同的方法。父類有時也叫基類、超類；子類有時也被稱為派生類。

我們來舉個例子：我們知道動物有很多種，是一個比較大的概念。在動物的種類中，我們熟悉的有貓(Cat)、狗(Dog)等動物，它們都有動物的一般特徵（比如能夠吃東西，能夠發出聲音），不過又在細節上有區別（不同動物的吃的不同，叫聲不一樣）。在Java語言中實現Cat和Dog等類的時候，就需要繼承Animal這個類。繼承之後Cat、Dog等具體動物類就是子類，Animal類就是父類。

為什麼需要繼承

你可能會疑問為什麼需要繼承？在具體實現的時候，我們建立Dog，Cat等類的時候實現其具體的方法不就可以了嘛，實現這個繼承似乎使得這個類的結構不那麼清晰。

如果僅僅只有兩三個類，每個類的屬性和方法很有限的情況下確實沒必要實現繼承，但事情並非如此，事實上一個系統中往往有很多個類並且有著很多相似之處，比如貓和狗同屬動物，或者學生和老師同屬人。各個類可能又有很多個相同的屬性和方法，這樣的話如果每個類都重新寫不僅程式碼顯得很亂，程式碼工作量也很大。

這時繼承的優勢就出來了：可以直接使用父類的屬性和方法，自己也可以有自己新的屬性和方法滿足擴充，父類的方法如果自己有需求更改也可以重寫。這樣使用繼承不僅大大的減少了程式碼量，也使得程式碼結構更加清晰可見。

所以這樣從程式碼的層面上來看我們設計這個完整的Animal類是這樣的：

class Animal
{
    public int id;
    public String name;
    public int age;
    public int weight;

    public Animal(int id, String name, int age, int weight) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.weight = weight;
    }
    //這裡省略get set方法
    public void sayHello()
    {
        System.out.println("hello");
    }
    public void eat()
    {
        System.out.println("I'm eating");
    }
    public void sing()
    {
        System.out.println("sing");
    }
}

而Dog，Cat，Chicken類可以這樣設計：

class Dog extends Animal//繼承animal
{
    public Dog(int id, String name, int age, int weight) {
        super(id, name, age, weight);//呼叫父類構造方法
    }
}
class Cat extends Animal{

    public Cat(int id, String name, int age, int weight) {
        super(id, name, age, weight);//呼叫父類構造方法
    }
}
class Chicken extends Animal{

    public Chicken(int id, String name, int age, int weight) {
        super(id, name, age, weight);//呼叫父類構造方法
    }
    //雞下蛋
    public void layEggs()
    {
        System.out.println("我是老母雞下蛋啦，咯噠咯！咯噠咯！");
    }
}

各自的類繼承Animal後可以直接使用Animal類的屬性和方法而不需要重複編寫，各個類如果有自己的方法也可很容易地擴充。上述程式碼中你需要注意extends就是用來實現繼承的。

繼承的分類

繼承分為單繼承和多繼承，Java語言只支援類的單繼承，但可以通過實現介面的方式達到多繼承的目的。我們先用一張表概述一下兩者的區別，然後再展開講解。

單繼承

單繼承，是一個子類只擁有一個父類，如我們上面講過的Animal類和它的子類。單繼承在類層次結構上比較清晰，但缺點是結構的豐富度有時不能滿足使用需求。

多繼承(Java不支援，但可以實現)

多繼承，是一個子類擁有多個直接的父類。這樣做的好處是子類擁有所有父類的特徵，子類的豐富度很高，但是缺點就是容易造成混亂。下圖為一個混亂的例子。

Java雖然不支援多繼承，但是Java有三種實現多繼承效果的方式，分別是內部類、多層繼承和實現介面。

內部類可以繼承一個與外部類無關的類，保證了內部類的獨立性，正是基於這一點，可以達到多繼承的效果。

多層繼承：子類繼承父類，父類如果還繼承其他的類，那麼這就叫多層繼承。這樣子類就會擁有所有被繼承類的屬性和方法。

實現介面無疑是滿足多繼承使用需求的最好方式，一個類可以實現多個介面滿足自己在豐富性和複雜環境的使用需求。類和介面相比，類就是一個實體，有屬性和方法，而介面更傾向於一組方法。舉個例子，就拿斗羅大陸的唐三來看，他存在的繼承關係可能是這樣的：

如何實現繼承

實現繼承除了上面用到的extends外，還可以用implements這個關鍵字實現。下面，讓我給你逐一講解一下。

extends關鍵字

在Java中，類的繼承是單一繼承，也就是說一個子類只能擁有一個父類，所以extends只能繼承一個類。其使用語法為：

class 子類名 extends 父類名{}

例如Dog類繼承Animal類，它是這樣的：

class Animal{} //定義Animal類
class Dog extends Animal{} //Dog類繼承Animal類

子類繼承父類後，就擁有父類的非私有的屬性和方法。如果不明白，請看這個案例，在IDEA下建立一個專案，建立一個test類做測試，分別建立Animal類和Dog類，Animal作為父類寫一個sayHello()方法，Dog類繼承Animal類之後就可以呼叫sayHello()方法。具體程式碼為：

class Animal {
    public void  sayHello()//父類的方法
    {
        System.out.println("hello,everybody");
    }
}
class Dog extends Animal//繼承animal
{ }
public class test {
    public static void main(String[] args) {
       Dog dog=new Dog();
       dog.sayHello();
    }
}

點選執行的時候Dog子類可以直接使用Animal父類的方法。

implements 關鍵字

使用implements 關鍵字可以變相使Java擁有多繼承的特性，使用範圍為類實現介面的情況，一個類可以實現多個介面(介面與介面之間用逗號分開)。Java介面是一系列方法的宣告，一個介面中沒有方法的具體實現 。子類實現介面的時候必須重寫介面中的方法。

我們來看一個案例，建立一個test2類做測試，分別建立doA介面和doB介面，doA介面宣告sayHello()方法，doB介面宣告eat()方法，建立Cat2類實現doA和doB介面，並且在類中需要重寫sayHello()方法和eat()方法。具體程式碼為：

interface doA{
     void sayHello();
}
interface doB{
     void eat();
    //以下會報錯 介面中的方法不能具體定義只能宣告
    //public void eat(){System.out.println("eating");}
}
class Cat2 implements  doA,doB{
    @Override//必須重寫介面內的方法
    public void sayHello() {
        System.out.println("hello!");
    }
    @Override
    public void eat() {
        System.out.println("I'm eating");
    }
}
public class test2 {
    public static void main(String[] args) {
        Cat2 cat=new Cat2();
        cat.sayHello();
        cat.eat();
    }
}

Cat類實現doA和doB介面的時候，需要實現其宣告的方法，點選執行結果如下，這就是一個類實現介面的簡單案例：

繼承的特點

繼承的主要內容就是子類繼承父類，並重寫父類的方法。使用子類的屬性或方法時候，首先要建立一個物件，而物件通過構造方法去建立，在構造方法中我們可能會呼叫子父類的一些屬性和方法，所以就需要提前掌握this和super關鍵字。建立完這個物件之後，在呼叫重寫父類的方法，並區別重寫和過載的區別。所以本節根據this、super關鍵字—>建構函式—>方法重寫—>方法過載的順序進行講解。

this和super關鍵字

this和super關鍵字是繼承中非常重要的知識點，分別表示當前物件的引用和父類物件的引用，兩者有很大相似又有一些區別。

this表示當前物件，是指向自己的引用。

this.屬性 // 呼叫成員變數，要區別成員變數和區域性變數
this.() // 呼叫本類的某個方法
this() // 表示呼叫本類構造方法

super表示父類物件，是指向父類的引用。

super.屬性 // 表示父類物件中的成員變數
super.方法() // 表示父類物件中定義的方法
super() // 表示呼叫父類構造方法

此外，this和super關鍵字只能出現在非static修飾的程式碼中。

this()和super()都只能在構造方法的第一行出現，如果使用this()表示呼叫當前類的其他構造方法，使用super()表示呼叫父類的某個構造方法，所以兩者只能根據自己使用需求選擇其一。

寫一個小案例，建立D1類和子類D2如下：

class D1{
    public D1() {}//無參構造
    public void sayHello() {
        System.out.println("hello");
    }
}
class D2 extends D1{
    public String name;
    public D2(){
        super();//呼叫父類構造方法
        this.name="BigSai";//給當前類成員變數賦值
    }
    @Override
    public void sayHello() {
        System.out.println("hello，我是"+this.name);
    }
    public void test()
    {
        super.sayHello();//呼叫父類方法
        this.sayHello();//呼叫當前類其他方法
    }
}
public class test8 {
    public static void main(String[] args) {
        D2 d2=new D2();
        d2.test();
    }
}

執行的結果為：

構造方法

構造方法是一種特殊的方法，它是一個與類同名的方法。物件的建立就通過構造方法來完成，其主要的功能是完成物件的初始化。但在繼承中構造方法是一種比較特殊的方法（比如不能繼承），所以要了解和學習在繼承中構造方法的規則和要求。

構造方法可分為有參構造和無參構造，這個可以根據自己的使用需求合理設定構造方法。但繼承中的構造方法有以下幾點需要注意：

父類的構造方法不能被繼承：

因為構造方法語法是與類同名，而繼承則不更改方法名，如果子類繼承父類的構造方法，那明顯與構造方法的語法衝突了。比如Father類的構造方法名為Father()，Son類如果繼承Father類的構造方法Father()，那就和構造方法定義：構造方法與類同名衝突了，所以在子類中不能繼承父類的構造方法，但子類會呼叫父類的構造方法。

子類的構造過程必須呼叫其父類的構造方法：

Java虛擬機器構造子類物件前會先構造父類物件，父類物件構造完成之後再來構造子類特有的屬性，這被稱為記憶體疊加。而Java虛擬機器構造父類物件會執行父類的構造方法，所以子類構造方法必須呼叫super()即父類的構造方法。就比如一個簡單的繼承案例應該這麼寫：

class A{
    public String name;
    public A() {//無參構造
    }
    public A (String name){//有參構造
    }
}
class B extends A{
    public B() {//無參構造
       super();
    }
    public B(String name) {//有參構造
      //super();
       super(name);
    }
}

如果子類的構造方法中沒有顯示地呼叫父類構造方法，則系統預設呼叫父類無引數的構造方法。

你可能有時候在寫繼承的時候子類並沒有使用super()呼叫，程式依然沒問題，其實這樣是為了節省程式碼，系統執行時會自動新增父類的無參構造方式，如果不信的話我們對上面的類稍作修改執行：

方法重寫(Override)

方法重寫也就是子類中出現和父類中一模一樣的方法(包括返回值型別，方法名，引數列表)，它建立在繼承的基礎上。你可以理解為方法的外殼不變，但是核心內容重寫。

在這裡提供一個簡單易懂的方法重寫案例：

class E1{
    public void doA(int a){
        System.out.println("這是父類的方法");
    }
}
class E2 extends E1{
    @Override
    public void doA(int a) {
        System.out.println("我重寫父類方法，這是子類的方法");
    }
}

其中@Override註解顯示宣告該方法為註解方法，可以幫你檢查重寫方法的語法正確性，當然如果不加也是可以的，但建議加上。

對於重寫，你需要注意以下幾點：

從重寫的要求上看：

重寫的方法和父類的要一致(包括返回值型別、方法名、引數列表)
方法重寫只存在於子類和父類之間，同一個類中只能過載

從訪問許可權上看：

子類方法不能縮小父類方法的訪問許可權
子類方法不能丟擲比父類方法更多的異常
父類的私有方法不能被子類重寫

從靜態和非靜態上看：

父類的靜態方法不能被子類重寫為非靜態方法
子類可以定義於父類的靜態方法同名的靜態方法，以便在子類中隱藏父類的靜態方法（滿足重寫約束）
父類的非靜態方法不能被子類重寫為靜態方法

從抽象和非抽象來看：

父類的抽象方法可以被子類通過兩種途徑重寫（即實現和重寫）
父類的非抽象方法可以被重寫為抽象方法

當然，這些規則可能涉及一些修飾符，在第三關中會詳細介紹。

方法過載(Overload)

如果有兩個方法的方法名相同，但引數不一致，那麼可以說一個方法是另一個方法的過載。方法過載規則如下：

被過載的方法必須改變引數列表(引數個數或型別或順序不一樣)
被過載的方法可以改變返回型別
被過載的方法可以改變訪問修飾符
被過載的方法可以宣告新的或更廣的檢查異常
方法能夠在同一個類中或者在一個子類中被過載
無法以返回值型別作為過載函式的區分標準

過載可以通常理解為完成同一個事情的方法名相同，但是引數列表不同其他條件也可能不同。一個簡單的方法過載的例子，類E3中的add()方法就是一個過載方法。

class E3{
    public int add(int a,int b){
        return a+b;
    }
    public double add(double a,double b) {
        return a+b;
    }
    public int add(int a,int b,int c) {
        return a+b+c;
    }
}

方法重寫和方法過載的區別：

方法重寫和方法過載名稱上容易混淆，但內容上有很大區別，下面用一個表格列出其中區別：

繼承與修飾

Java修飾符的作用就是對類或類成員進行修飾或限制，每個修飾符都有自己的作用，而在繼承中可能有些特殊修飾符使得被修飾的屬性或方法不能被繼承，或者繼承需要一些其他的條件，下面就詳細介紹在繼承中一些修飾符的作用和特性。

Java語言提供了很多修飾符，修飾符用來定義類、方法或者變數，通常放在語句的最前端。主要分為以下兩類：

訪問修飾符
非訪問修飾符

這裡訪問修飾符主要講解public，protected，default，private四種訪問控制修飾符。非訪問修飾符這裡就介紹static修飾符，final修飾符和abstract修飾符。

訪問修飾符

public，protected，default(無修飾詞)，private修飾符是物件導向中非常重要的知識點，而在繼承中也需要懂得各種修飾符使用規則。

首先我們都知道不同的關鍵字作用域不同，四種關鍵字的作用域如下：

private：Java語言中對訪問許可權限制的最窄的修飾符，一般稱之為“私有的”。被其修飾的屬性以及方法只能被該類的物件訪問，其子類不能訪問，更不能允許跨包訪問。
default：(也有稱friendly)即不加任何訪問修飾符，通常稱為“預設訪問許可權“或者“包訪問許可權”。該模式下，只允許在同一個包中進行訪問。
protected：介於public 和 private 之間的一種訪問修飾符，一般稱之為“保護訪問許可權”。被其修飾的屬性以及方法只能被類本身的方法及子類訪問，即使子類在不同的包中也可以訪問。
public： Java語言中訪問限制最寬的修飾符，一般稱之為“公共的”。被其修飾的類、屬性以及方法不僅可以跨類訪問，而且允許跨包訪問。

Java 子類重寫繼承的方法時，不可以降低方法的訪問許可權，子類繼承父類的訪問修飾符作用域不能比父類小，也就是更加開放，假如父類是protected修飾的，其子類只能是protected或者public，絕對不能是default(預設的訪問範圍)或者private。所以在繼承中需要重寫的方法不能使用private修飾詞修飾。

如果還是不太清楚可以看幾個小案例就很容易搞懂，寫一個A1類中用四種修飾詞實現四個方法，用子類A2繼承A1，重寫A1方法時候你就會發現父類私有方法不能重寫，非私有方法重寫使用的修飾符作用域不能變小(大於等於)。

正確的案例應該為：

class A1 {
    private void doA(){ }
    void doB(){}//default
    protected void doC(){}
    public void doD(){}
}
class A2 extends A1{

    @Override
    public void doB() { }//繼承子類重寫的方法訪問修飾符許可權可擴大

    @Override
    protected void doC() { }//繼承子類重寫的方法訪問修飾符許可權可和父類一致

    @Override
    public void doD() { }//不可用protected或者default修飾
}

還要注意的是，繼承當中子類丟擲的異常必須是父類丟擲的異常或父類丟擲異常的子異常。下面的一個案例四種方法測試可以發現子類方法的異常不可大於父類對應方法丟擲異常的範圍。

正確的案例應該為：

class B1{
    public void doA() throws Exception{}
    public void doB() throws Exception{}
    public void doC() throws IOException{}
    public void doD() throws IOException{}
}
class B2 extends B1{
    //異常範圍和父類可以一致
    @Override
    public void doA() throws Exception { }
    //異常範圍可以比父類更小
    @Override
    public void doB() throws IOException { }
    //異常範圍 不可以比父類範圍更大
    @Override
    public void doC() throws IOException { }//不可丟擲Exception等比IOException更大的異常
    @Override
    public void doD() throws IOException { }
}

非訪問修飾符

訪問修飾符用來控制訪問許可權，而非訪問修飾符每個都有各自的作用，下面針對static、final、abstract修飾符進行介紹。

static 修飾符

static 翻譯為“靜態的”，能夠與變數，方法和類一起使用，稱為靜態變數，靜態方法(也稱為類變數、類方法)。如果在一個類中使用static修飾變數或者方法的話，它們可以直接通過類訪問，不需要建立一個類的物件來訪問成員。

我們在設計類的時候可能會使用靜態方法，有很多工具類比如Math，Arrays等類裡面就寫了很多靜態方法。static修飾符的規則很多，這裡僅僅介紹和Java繼承相關用法的規則：

構造方法不允許宣告為 static 的。
靜態方法中不存在當前物件，因而不能使用 this，當然也不能使用 super。
靜態方法不能被非靜態方法重寫(覆蓋)
靜態方法能被靜態方法重寫(覆蓋)

可以看以下的案例證明上述規則：

原始碼為：

class C1{
    public  int a;
    public C1(){}
   // public static C1(){}// 構造方法不允許被宣告為static
    public static void doA() {}
    public static void doB() {}
}
class C2 extends C1{
    public static  void doC()//靜態方法中不存在當前物件，因而不能使用this和super。
    {
        //System.out.println(super.a);
    }
    public static void doA(){}//靜態方法能被靜態方法重寫
   // public void doB(){}//靜態方法不能被非靜態方法重寫
}

final修飾符

final變數：

final 表示"最後的、最終的"含義，變數一旦賦值後，不能被重新賦值。被 final 修飾的例項變數必須顯式指定初始值(即不能只宣告)。final 修飾符通常和 static 修飾符一起使用來建立類常量。

final 方法：

父類中的 final 方法可以被子類繼承，但是不能被子類重寫。宣告 final 方法的主要目的是防止該方法的內容被修改。

final類：

final 類不能被繼承，沒有類能夠繼承 final 類的任何特性。

所以無論是變數、方法還是類被final修飾之後，都有代表最終、最後的意思。內容無法被修改。

abstract 修飾符

abstract 英文名為“抽象的”，主要用來修飾類和方法，稱為抽象類和抽象方法。

抽象方法：有很多不同類的方法是相似的，但是具體內容又不太一樣，所以我們只能抽取他的宣告，沒有具體的方法體，即抽象方法可以表達概念但無法具體實現。

抽象類：有抽象方法的類必須是抽象類，抽象類可以表達概念但是無法構造實體的類。

抽象類和抽象方法內容和規則比較多。這裡只提及一些和繼承有關的用法和規則：

抽象類也是類，如果一個類繼承於抽象類，就不能繼承於其他的（類或抽象類）
子類可以繼承於抽象類，但是一定要實現父類們所有abstract的方法。如果不能完全實現，那麼子類也必須被定義為抽象類
只有實現父類的所有抽象方法，才能是完整類。

比如我們可以這樣設計一個People抽象類以及一個抽象方法，在子類中具體完成：

abstract class People{
    public abstract void sayHello();//抽象方法
}
class Chinese extends People{
    @Override
    public void sayHello() {//實現抽象方法
        System.out.println("你好");
    }
}
class Japanese extends People{
    @Override
    public void sayHello() {//實現抽象方法
        System.out.println("口你七哇");
    }
}
class American extends People{
    @Override
    public void sayHello() {//實現抽象方法
        System.out.println("hello");
    }
}

Object類和轉型

提到Java繼承，不得不提及所有類的根類：Object(java.lang.Object)類，如果一個類沒有顯式宣告它的父類（即沒有寫extends xx），那麼預設這個類的父類就是Object類，任何類都可以使用Object類的方法，建立的類也可和Object進行向上、向下轉型，所以Object類是掌握和理解繼承所必須的知識點。而Java向上和向下轉型在Java中運用很多，也是建立在繼承的基礎上，所以Java轉型也是掌握和理解繼承所必須的知識點。

Object類概述

Object是類層次結構的根類，所有的類都隱式的繼承自Object類。
Java所有的物件都擁有Object預設方法
Object類的構造方法有一個，並且是無參構造

Object是java所有類的父類，是整個類繼承結構的頂端，也是最抽象的一個類。像toString()、equals()、hashCode()、wait()、notify()、getClass()等都是Object的方法。你以後可能會經常碰到，但其中遇到更多的就是toString()方法和equals()方法，我們經常需要重寫這兩種方法滿足我們的使用需求。

**toString()**方法表示返回該物件的字串，由於各個物件構造不同所以需要重寫，如果不重寫的話預設返回類名@hashCode格式。

如果重寫toString()方法後直接呼叫toString()方法就可以返回我們自定義的該類轉成字串型別的內容輸出，而不需要每次都手動的拼湊成字串內容輸出，大大簡化輸出操作。

**equals()方法主要比較兩個物件是否相等，因為物件的相等不一定非要嚴格要求兩個物件地址上的相同，有時內容上的相同我們就會認為它相等，比如String 類就重寫了euqals()**方法，通過字串的內容比較是否相等。

向上轉型

向上轉型 : 通過子類物件(小範圍)例項化父類物件(大範圍)，這種屬於自動轉換。用一張圖就能很好地表示向上轉型的邏輯：

父類引用變數指向子類物件後，只能使用父類已宣告的方法，但方法如果被重寫會執行子類的方法，如果方法未被重寫那麼將執行父類的方法。

向下轉型

向下轉型 : 通過父類物件(大範圍)例項化子類物件(小範圍)，在書寫上父類物件需要加括號()強制轉換為子類型別。但父類引用變數實際引用必須是子類物件才能成功轉型，這裡也用一張圖就能很好表示向上轉型的邏輯：

子類引用變數指向父類引用變數指向的物件後(一個Son()物件)，就完成向下轉型，就可以呼叫一些子類特有而父類沒有的方法。

在這裡寫一個向上轉型和向下轉型的案例：

Object object=new Integer(666);//向上轉型

Integer i=(Integer)object;//向下轉型Object->Integer，object的實質還是指向Integer

String str=(String)object;//錯誤的向下轉型，雖然編譯器不會報錯但是執行會報錯

子父類初始化順序

在Java繼承中，父子類初始化先後順序為：

父類中靜態成員變數和靜態程式碼塊
子類中靜態成員變數和靜態程式碼塊
父類中普通成員變數和程式碼塊，父類的建構函式
子類中普通成員變數和程式碼塊，子類的建構函式

總的來說，就是靜態>非靜態，父類>子類，非建構函式>建構函式。同一類別（例如普通變數和普通程式碼塊）成員變數和程式碼塊執行從前到後，需要注意邏輯。

這個也不難理解，靜態變數也稱類變數，可以看成一個全域性變數，靜態成員變數和靜態程式碼塊在類載入的時候就初始化，而非靜態變數和程式碼塊在物件建立的時候初始化。所以靜態快於非靜態初始化。

而在建立子類物件的時候需要先建立父類物件，所以父類優先於子類。

而在呼叫建構函式的時候，是對成員變數進行一些初始化操作，所以普通成員變數和程式碼塊優於建構函式執行。

至於更深層次為什麼這個順序，就要更深入瞭解JVM執行流程啦。下面一個測試程式碼為：

class Father{
    public Father() {
        System.out.println(++b1+"父類構造方法");
    }//父類構造方法 第四
    static int a1=0;//父類static 第一 注意順序
    static {
        System.out.println(++a1+"父類static");
    }
    int b1=a1;//父類成員變數和程式碼塊 第三
    {
        System.out.println(++b1+"父類程式碼塊");
    }
}
class Son extends Father{
    public Son() {
        System.out.println(++b2+"子類構造方法");
    }//子類構造方法 第六
    static {//子類static第二步
        System.out.println(++a1+"子類static");
    }
    int b2=b1;//子類成員變數和程式碼塊 第五
    {
        System.out.println(++b2 + "子類程式碼塊");
    }
}
public class test9 {
    public static void main(String[] args) {
        Son son=new Son();
    }
}

執行結果：

結語

好啦，本次繼承就介紹到這裡啦，Java物件導向三大特徵之一繼承——優秀的你已經掌握。再看看Java物件導向三大特性：封裝、繼承、多型。最後問你能大致瞭解它們的特徵嘛？

封裝：是對類的封裝，封裝是對類的屬性和方法進行封裝，只對外暴露方法而不暴露具體使用細節，所以我們一般設計類成員變數時候大多設為私有而通過一些get、set方法去讀寫。

繼承：子類繼承父類，即“子承父業”，子類擁有父類除私有的所有屬性和方法，自己還能在此基礎上擴充自己新的屬性和方法。主要目的是複用程式碼。

多型：多型是同一個行為具有多個不同表現形式或形態的能力。即一個父類可能有若干子類，各子類實現父類方法有多種多樣，呼叫父類方法時，父類引用變數指向不同子類例項而執行不同方法，這就是所謂父類方法是多型的。

最後送你一張圖捋一捋其中的關係吧。

點選關注，第一時間瞭解華為雲新鮮技術~

史上最為詳細的javascript繼承
2019-05-16
JavaScript繼承
Java 繼承詳解
2015-06-13
Java繼承
Java泛型詳解，史上最全圖文詳解！
2022-02-14
Java泛型
EventBus 3.0+ 原始碼詳解（史上最詳細圖文講解）
2018-07-30
原始碼
java繼承基礎詳解
2021-08-02
Java繼承
Java集合繼承圖
2018-05-21
Java繼承
C++繼承詳解：共有(public)繼承，私有(private)繼承，保護(protected)繼承
2017-07-30
C++繼承
js繼承圖解
2020-12-05
JS繼承圖解
Kotlin——中級篇（四）：繼承類詳解
2019-03-04
Kotlin繼承
三種繼承的方法:public 繼承/private繼承/protected繼承詳解及區別
2013-11-29
繼承
JavaScript繼承詳解（二）
2021-09-09
JavaScript繼承
JavaScript 繼承方式詳解
2016-09-06
JavaScript繼承
圖解js的繼承
2020-12-06
圖解JS繼承
類的繼承圖解
2018-04-06
繼承圖解
js 組合繼承詳解
2021-11-04
JS繼承
Python super繼承詳解
2015-02-08
Python繼承
python 多繼承詳解
2013-08-28
Python繼承
c++ 虛繼承詳解
2013-05-03
C++繼承
詳解JS的繼承（三）-- 圖解Es6的Extend
2022-01-15
JS繼承圖解
圖解JavaScript原型鏈繼承
2019-02-24
圖解JavaScript原型繼承
Java繼承
2016-11-01
Java繼承
java繼承extends
2020-11-29
Java繼承
Java的繼承
2023-02-27
Java繼承
Java單繼承
2017-06-14
Java繼承
java中繼承
2017-12-25
Java中繼繼承
JAVA 之繼承
2015-04-10
Java繼承
Java繼承中成員變數的訪問特點「圖文分析」包含繼承中重名訪問的特點
2020-10-04
Java繼承變數
事務隔離級別(圖文詳解)
2019-04-10
JasperReport初級教程(2.0.3)圖文詳解
2009-11-17
最簡單的原型繼承
2015-12-06
原型繼承
Java實現多執行緒詳解一 ( 繼承Thread方式 )
2020-11-14
Java執行緒繼承thread
JAVA中的註解可以繼承嗎？
2022-12-13
Java繼承
二、Java初級--8、繼承和重寫方法
2018-03-06
Java繼承
springmvc中Dispatchservlet繼承體系詳解
2018-11-12
SpringMVCServlet繼承
odoo 繼承（owl繼承、web繼承、view繼承）
2024-03-29
Odoo繼承WebView
? 一文看懂 JS 繼承
2019-03-17
JS繼承
java -繼承 -重寫
2020-10-29
Java繼承
Java繼承練習
2020-12-04
Java繼承