一、什么是繼承？

在學習之前，我們先要了解一下什么叫繼承，簡單點講就是：

在很多個類中存在相同屬性和行為時，把這些相同內容以及相同屬性單獨抽取到一個類中，那這些類就不用重新定義這些屬性和行為，只要繼承那個類就好了。

很多個類可以稱之為子類，單獨的這個類可以稱之為父類、超類或者基類。子類呢，可以直接訪問父類中的非私有的屬性以及行為。也可以通過 extends 關鍵字讓類與類之間產生繼承關系。這樣聽懂了嗎？是不是很簡單，我們通過案例來進一步了解~

class Dog extends Animal
    //Dog 是子類  //Animal是父類

二、那為什么要繼承呢？

2.1 繼承的方式

當多個類存在相同的屬性以及方法的時候，每次都需要描述時，都需要寫一遍，這樣代碼的冗余率很高，也很浪費效率，但是如果能夠有一個繼承機制，我們就能夠把這些相同的屬性和方法給它抽調出來，書寫成一個父類，當子類需要的時候，直接繼承就好了，不需要在對這部分進行書寫，只需要進行補充就好啦。效率就大大提高了~

代碼如下（示例）：

class Animal {
 
    public String name;
    public int age;
    public void eat() {
 
        System.out.println(name+"正在吃飯! ");
    }
}
class Dog extends Animal {
 
    public void bark() {
 
        System.out.println(name+"汪汪叫! ");
    }
}
class Cat extends Animal {
 
    public void mew() {
 
        System.out.println(name+"喵喵叫! ");
    }
}

咱們這里是用動物來舉例子，生活中最常見的就是貓貓和狗，貓貓和狗狗的特性一般都有，咱們會給它們取名字，還有年齡，同時也吃東西等等這些共性，當然還有很多相同之點，就不一個一個舉例了。我們可以將這些共性呢，寫成一個Animal類，直接繼承，然后寫入特有的bark和mew方法即可：

繼承的優點:

1.提高代碼的復用性。

2.讓類與類之間產生了關系，是多態的前提。

2.2 繼承的特點

1.JAVA只支持單繼承，不支持多繼承。

2.Java支持多層（重）繼承(繼承體系)。

3.繼承關系一般不希望超過三層，如果超過那么就考慮重構了.

三、繼承后如何訪問？

3.1訪問父類成員變量

代碼如下（示例）

//不存在同名的情況
class Father {
 
    int a;
    int b;
}
class Son extends Father {
 
    int c;
    public void func() {
 
        a = 10;
        b = 20;
        c = 30;
    }
}

在這里a,b直接訪問的時父類繼承下來的a,b，能夠直接進行賦值

//父類和子類成員變量同名
class Father {
 
    int a;
    int b;
}
class Son extends Father {
 
    int a;
    int b;
    int c;
    public void func() {
 
        a = 10;
        b = 20;
        c = 30;
    }
}

在這里a,b訪問的是子類中的a,b

總結：

1.如果訪問的成員變量如果子類有，優先訪問子類的。

2.如果子類中無，則訪問父類中的，如果父類也沒有，則編譯失敗.

3.如果訪問子類父類中都有，則優先訪問子類的，采用的就是一個就近原則

3.2訪問父類成員方法

//父類子類成員方法名不同
class Father {
 
    public void func1() {
 
        System.out.println("func1");
    }
}    
class Son extends Father {
 
    public void func2() {
 
        System.out.println("func2");
    }
    public void func3() {
 
     func1();
     func2();
    }
}

在func3()中訪問的func1()是父類的func1()

class Father {
 
    public void func1() {
 
        System.out.println("Father: func1");
    }
}
class Son extends Father {
 
    public void func1() {
 
        System.out.println("Son: func1");
    }
    public void func2() {
 
        System.out.println("Son: func2");
    }
    public void func3() {
 
        func1();
        func2();
    }
}

在func3()中訪問的func1()是子類的func1()

總結：

1.子類與父類方法名不同時，優先在子類找，如果子類找不到，則去父類找，如果父類找不到，則編譯錯誤。

2.子類與父類同名方法時，如果父類和子類同名方法的參數不同，則根據調用選擇合適的參數進行訪問，如果沒有合適的則報錯誤.

四、super的使用

如果子類中存在與父類中相同的成員時，那如何在子類中訪問父類相同名稱的成員呢？

可以使用super關鍵字進行訪問.

4.1 訪問父類的成員

class Father {
 
    int a;
    int b;
}
class Son extends Father {
 
    int a;
    int b;
    int c;
    public void func() {
 
        super.a = 10;
        super.b = 20;
        c = 30;
    }
}

4.2 訪問父類的方法

class Father {
 
    public void func1() {
 
        System.out.println("Father: func1");
    }
}
class Son extends Father {
 
    public void func1() {
 
        System.out.println("Son: func1");
    }
    public void func2() {
 
        System.out.println("Son: func2");
    }
    public void func3() {
 
        super.func1();
        func2();
    }
}

注意:

1.super只能在非靜態方法中使用

2.在子類方法中，訪問父類的成員變量和方法

4.3 子類構造方法

在生成子類對象時，會先調用父類的構造方法，在去執行子類的構造方法.一般沒有寫出來，系統會默認寫入.

class Father {
 
    public Father() {
 
        System.out.println("Father!");
    }
}
class Son extends Father {
 
    public Son() {
 
        //super();
        System.out.println("Son!");
    }

    public static void main(String[] args) {
 
        Son son = new Son();
    }
}

這里驗證了我們所說的，在實例子類對象時，會先調用父類的實例方法，然后在調用我們子類的實例方法，在子類的構造方法默認有一個super()方法去調用父類的構造方法，如果我們自己寫的父類的構造方法是帶參數的，我們但自己在子類構造方法第一行寫super(參數)不然會編譯報錯.

4.4 super和this

1.super是一個關鍵字，代表父類的存儲空間標識。(可以理解為父親的引用)

2.super和this的用法相似。

3.this代表對象的引用(誰調用就代表誰)；

4.super代表當前子類對父類的引用。

5.super();和this();都是在構造函數的第一行，不能同時出現。

不同點

1.成員變量

this.變量        本類的
super.變量       父類的

2.構造方法

this(...)        本類的
super(...)       父類的

3.成員方法

this.方法名()        本類的    
super.方法名()       父類的

4.5 繼承代碼塊執行順序

1.父類靜態代碼塊優先執行，然后子類靜態代碼塊執行，靜態代碼塊只執行一次

2.在實例子類對象時，父類實例代碼塊和父類構造方法緊接著執行.

3.子類的實例代碼塊和子類構造方法再執行

五、組合

5.1 final關鍵字

1.final修飾變量表示常量，不能再修改(常量書寫默認為單詞的大寫)

final int COUNT = 0;
COUNT = 10;//編譯錯誤

2.final修飾類表示該類不能在被繼承

final class Father {
 

}
class Son extends Father {
 

}

3.final修飾的方法不能夠重寫

5.2 組合

組合表示的是:對象之間存在has的關系，其中一個類是其他幾個類的組合.

class Tire {
 

}
class Engine {
 

}
class VehicleSystem {
 

}
class Car {
 
    private Tire tire;
    private Engine engine;
    private VehicleSystem vehicleSystem;
}
class Ferrari extends Car {
 
    
}

今天這篇文章就先寫到這里啦，喜歡的話，可以點贊，關注+評論，同時呢，也可以轉發一下，讓更多的朋友看到~~