點擊上方藍字關注我，設爲星標，任何轉載請滴滴我受權前端
課程導學
在Java課堂中，全部老師不得不提到面向對象（Object Oriented），而在談到面向對象的時候，又不得不提到面向對象的三大特徵：封裝、繼承、多態。三大特徵緊密聯繫而又有區別，本課程就帶你學習Java的繼承。java
你可能不知道繼承到底有什麼用，但你大機率曾有過這樣的經歷：寫Java項目/做業時候建立不少類似的類，類中也有不少相同的方法，作了不少重複的工做量，感受很臃腫。而合理使用繼承就能大大減小重複代碼，提升代碼複用性。web
繼承的初相識
學習繼承，確定是先從廣的概念瞭解繼承是什麼以及其做用，而後才從細的方面學習繼承的具體實現細節，本關就是帶你先快速瞭解和理解繼承的重要概念。面試
什麼是繼承
繼承（英語：inheritance）是面向對象軟件技術中的一個概念。它使得複用之前的代碼很是容易，可以大大縮短開發週期，下降開發費用。緩存
Java語言是很是典型的面向對象的語言，在Java語言中繼承就是子類繼承父類的屬性和方法，使得子類對象（實例）具備父類的屬性和方法，或子類從父類繼承方法，使得子類具備父類相同的方法。父類有時也叫基類、超類；子類有時也被稱爲派生類。微信
咱們來舉個例子：咱們知道動物有不少種，是一個比較大的概念。在動物的種類中，咱們熟悉的有貓(Cat)、狗(Dog)等動物，它們都有動物的通常特徵（好比可以吃東西，可以發出聲音），不過又在細節上有區別（不一樣動物的吃的不一樣，叫聲不同）。在Java語言中實現Cat和Dog等類的時候，就須要繼承Animal這個類。繼承以後Cat、Dog等具體動物類就是子類，Animal類就是父類。app
爲何須要繼承
你可能會疑問爲何須要繼承？在具體實現的時候，咱們建立Dog，Cat等類的時候實現其具體的方法不就能夠了嘛，實現這個繼承彷佛使得這個類的結構不那麼清晰。編輯器
若是僅僅只有兩三個類，每一個類的屬性和方法頗有限的狀況下確實不必實現繼承，但事情並不是如此，事實上一個系統中每每有不少個類而且有着不少類似之處，好比貓和狗同屬動物，或者學生和老師同屬人。各個類可能又有不少個相同的屬性和方法，這樣的話若是每一個類都從新寫不只代碼顯得很亂，代碼工做量也很大。ide
這時繼承的優點就出來了：能夠直接使用父類的屬性和方法，本身也能夠有本身新的屬性和方法知足拓展，父類的方法若是本身有需求更改也能夠重寫。這樣使用繼承不只大大的減小了代碼量，也使得代碼結構更加清晰可見。svg
因此這樣從代碼的層面上來看咱們設計這個完整的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修飾符是面向對象中很是重要的知識點，而在繼承中也須要懂得各類修飾符使用規則。
首先咱們都知道不一樣的關鍵字做用域不一樣，四種關鍵字的做用域以下：
| 同一個類 | 同一個包 | 不一樣包子類 | 不一樣包非子類 | |
|---|---|---|---|---|
| private | ✅ | |||
| default | ✅ | ✅ | ||
| protect | ✅ | ✅ | ✅ | |
| public | ✅ | ✅ | ✅ | ✅ |
-
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方法去讀寫。
繼承：子類繼承父類，即「子承父業」，子類擁有父類除私有的全部屬性和方法，本身還能在此基礎上拓展本身新的屬性和方法。主要目的是複用代碼。
多態：多態是同一個行爲具備多個不一樣表現形式或形態的能力。即一個父類可能有若干子類，各子類實現父類方法有多種多樣，調用父類方法時，父類引用變量指向不一樣子類實例而執行不一樣方法，這就是所謂父類方法是多態的。
最後送你一張圖捋一捋其中的關係吧。
近期精彩：
好了，不說了，我們下次再見！本文同時收錄在回車課堂！歡迎查看。最後bigsai請大家在看、關注支持一波原創小博主，謝謝！
本文分享自微信公衆號 - bigsai（bigsai）。
若有侵權，請聯繫 support@oschina.cn 刪除。
本文參與「OSC源創計劃」，歡迎正在閱讀的你也加入，一塊兒分享。