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

原創公眾號：「bigsai」 除公眾號以外拒絕任意擅自轉載
文章收錄在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語言只支持類的單繼承，但可以通過實作介面的方式達到多繼承的目的，我們先用一張表概述一下兩者的區別，然后再展開講解，

	定義	優缺點
單繼承	一個子類只擁有一個父類	優點：在類層次結構上比較清晰 缺點：結構的豐富度有時不能滿足使用需求
多繼承（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修飾符是面向物件中非常重要的知識點，而在繼承中也需要懂得各種修飾符使用規則，

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

1. private：Java語言中對訪問權限限制的最窄的修飾符，一般稱之為“私有的”，被其修飾的屬性以及方法只能被該類的物件訪問，其子類不能訪問，更不能允許跨包訪問，

2. default：(也有稱friendly)即不加任何訪問修飾符，通常稱為“默認訪問權限“或者“包訪問權限”，該模式下，只允許在同一個包中進行訪問，

3. protected：介于public 和 private 之間的一種訪問修飾符，一般稱之為“保護訪問權限”，被其修飾的屬性以及方法只能被類本身的方法及子類訪問，即使子類在不同的包中也可以訪問，

4. 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類概述

1. Object是類層次結構的根類，所有的類都隱式的繼承自Object類，

2. Java所有的物件都擁有Object默認方法

3. 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繼承中，父子類初始化先后順序為：

1. 父類中靜態成員變數和靜態代碼塊

2. 子類中靜態成員變數和靜態代碼塊

3. 父類中普通成員變數和代碼塊，父類的建構式

4. 子類中普通成員變數和代碼塊，子類的建構式

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

這個也不難理解，靜態變數也稱類變數，可以看成一個全域變數，靜態成員變數和靜態代碼塊在類加載的時候就初始化，而非靜態變數和代碼塊在物件創建的時候初始化，所以靜態快于非靜態初始化，

而在創建子類物件的時候需要先創建父類物件，所以父類優先于子類，

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

至于更深層次為什么這個順序，就要更深入了解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方法去讀寫，

繼承：子類繼承父類，即“子承父業”，子類擁有父類除私有的所有屬性和方法，自己還能在此基礎上拓展自己新的屬性和方法，主要目的是復用代碼，

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

最后送你一張圖捋一捋其中的關系吧，

原創不易，bigsai請你幫兩件事幫忙一下:

1. 一鍵三連支持一下， 您的肯定是我在平臺創作的源源動力，

2. 微信搜索「bigsai」，關注我的公眾號(原創干貨博主)，不僅免費送你電子書，我還會第一時間在公眾號分享知識技術，加我還可拉你進力扣打卡群一起打卡LeetCode，

3. 最近在將csdn的文章整理成電子書，即將第一時間給大家免費放送，