1.作用：為方法覆蓋和多型機制做準備；使程式碼得到複用（節省程式碼量）...2.格式： class 子類 extends 父類... 3.理解繼承：子類繼承父類，其實就相當於把父類的類體中的所有程式碼（除了構造方法）複製，貼上到子類的類體裡...4.當一個類沒有繼承父類時，將預設繼承object類，object類為Java語言提供的“ 祖宗 ”類 “ Java中所有類都會直接 / 間接繼承object類，因為即使一個類繼承了其他父類，但是它的父類或者父類的父類...總會預設繼承object類吧...5.super : 就一個有用的效果---在子類的構造方法中通過super呼叫上一個父類的構造來初始化屬性.......

繼承（extends）：

1.作用：為方法覆蓋和多型機制做準備；使程式碼得到複用（節省程式碼量）；

2.格式： class 子類 extends 父類

3.理解繼承：子類繼承父類，其實就相當於把父類的類體中的所有程式碼（除了構造方法）複製，貼上到子類的類體裡；

4.當一個類沒有繼承父類時，將預設繼承object類，object類為Java語言提供的“ 祖宗 ”類 “；Java中所有類都會直接 / 間接繼承object類，因為即使一個類繼承了其他父類，但是它的父類或者父類的父類...總會預設繼承object類吧；

5.super : 就一個有用的效果---在子類的構造方法中通過super呼叫上一個父類的構造來初始化屬性；

注意：1）super只能出現在構造方法的第一行；

2）當第一行我們沒有手動呼叫super時，系統會預設有一個“ super ( ) ”，目的是在呼叫子類構造方法時，先對父類屬性進行初始化；

3）不管咱在子類構造方法中調不呼叫super，super總會出現並起作用的，所以父類的無參構造方法一定不能少（否則獎勵報錯）。在每一個類體中都把無參構造方法寫進去也是一個程式設計師必不可少的習慣；

4）this ( ) 與super ( ) 會衝突，不用細扣，反正 this 就是用來區分同名的形參和例項變數的，你寫在構造方法裡幹嘛，對吧；

輔助程式碼理解：

class Animal{
    int a;
    String b;
    public Animal() {
    }
    public Animal(int a, String b) {
        this.a = a;
        this.b = b;
    }
    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }
    public String getB() {
        return b;
    }
    public void setB(String b) {
        this.b = b;
    }
    public void put(){
        System.out.println(a+b);
    }
}
    
class Panda extends Animal {
//    int a;
//    String b;
    public Panda() {
    }
    public Panda(int a, String b) {
        super(a, b);
    }
//    public int getA() {
//        return a;
//    }
//    public void setA(int a) {
//        this.a = a;
//    }
//    public String getB() {
//        return b;
//    }
//    public void setB(String b) {
//        this.b = b;
//    }
//    public void put(){
//        System.out.println(a+b);
//    }
}
 

如上程式碼：因為Panda類繼承了Animal類，所以Animal類中除構造方法以外的所有程式碼（在Panda類體中被註釋的程式碼）都複製貼上到了Panda的類體中( 隱藏了)，所以說Panda類中看似只有倆個構造方法的程式碼，但其實被註釋掉的程式碼也相當於它的程式碼；

注意：

1）Java中只支援單繼承，不支援多繼承，eg： class A extends S , Z ( 錯誤寫法) ；

2）除構造方法以外，子類會繼承父類中的所有程式碼；

3）當我們修改了父類類體中的程式碼（除構造方法外）時，那麼直接繼承 / 間接繼承 它的類中的對應的程式碼也會發生改變；

4）object類體中有一個方法名為“ toString ”，返回值型別為“ String ”的方法，我們在主方法中建立一個物件後，再利用" System . out . print ( 引用 ) 就可以輸出“ toString ”中的返回值；

方法覆蓋；

1.作用物件；只會發生在有 直接繼承 / 間接繼承 關係的倆個類之間；

2.上面提到子類會將父類中除了構造方法以外的所有程式碼都複製貼上到子類中，那麼貼上過來的方法可不可以進行重寫呢？可以，但是注意：第一，訪問許可權不能降低，只能升高；第二，返回值型別不能改變；第三，方法名必須相同；第四，引數列表必須相同；

輔助理解程式碼：

class Animal{
    String a;
    public Animal() {
    }
    public Animal(String a) {
        this.a = a;
    }
    public void put(){
        System.out.println("父類方法執行！");
    }
    public String toString(){
        return "一種動物";
    }
}

class Panda extends Animal {
    public Panda() {
    }
    public Panda(String a) {
        super(a);
    }
    //對父類中的 put 方法進行方法覆蓋
    public void put(){
        System.out.println("我就不執行父類方法！我就執行我重寫的！");
    }
    //對父類中的 toString 方法進行方法覆蓋
    public String toString(){
        return "一隻熊貓";
    }
}
public class pra{
    public static void main(String[] args) {
        Animal an=new Animal();
        an.put();//呼叫此物件的 put 方法
        System.out.println(an.toString());//輸出此物件的 toString 方法的返回值
        Panda pa=new Panda();
        pa.put();//呼叫此物件重寫過的 put 方法
        System.out.println(pa.toString());//輸出此物件重寫之後的 toString 方法的返回值
    }
}

----------------------------------------------
輸出結果；

父類方法執行！
一種動物
我就不執行父類方法！我就執行我重寫的！
一隻熊貓

Process finished with exit code 0

多型機制：

1.概念：使得同一個屬性或方法在父類及其各個子類中具有不同的含義；程式碼體現：父類引用指向子型別物件；

2.Java程式分為編譯階段和執行階段，就” 通過子類的構造方法建立物件，並用父類的引用資料變數儲存物件地址 “談談：

編譯階段，編譯器會到引用資料型別對應的父類中找（後面子類呼叫的）構造方法，找到了，靜態繫結成功；執行階段，由於在堆記憶體建立的是子類的物件，所以執行階段繫結的是子類的構造方法，動態繫結成功；所以當用” 父類的引用 . “ 的方式呼叫方法時，實際執行的是子類中的（方法覆蓋的）的方法，訪問屬性也是同理；

3.意義：提高程式的拓展性，降低耦合性；

輔助理解程式碼；

class Master{
    private String name;
    private Pet pet;
    public Master(){
    }
    public Master(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Pet getPet() {
        return pet;
    }
    public void setPet(Pet pet) {
        this.pet = pet;
    }
    public void feed(Pet pet){
        pet.eat();
    }
}
class Pet{
    public Pet(){
    }
    public void eat(){
        System.out.println("寵物在吃主人喂的食物");
    }
}
class Dog extends Pet{
    public Dog(){
    }
    public void eat(){
        System.out.println("狗在吃主人喂的狗糧");
    }
}
class Cat extends Pet{
    public Cat(){
    }
    public void eat(){
        System.out.println("貓在吃主人喂的貓糧");
    }
}
//以後張三又喜歡養其他的寵物了，就不需要修改張三的feed方法(多型機制的好處)，只需再新增一個新寵物子類即可
public class 主人喂寵物 {
    public static void main(String[] args){
        Master M=new Master("張三");//建立主人物件-張三
        Pet p1=new Dog();//建立寵物1(靜態繫結) 狗(動態繫結)---真正的物件
        Pet p2=new Cat();//建立寵物2(靜態繫結) 貓(動態繫結)---真正的物件
        M.setPet(p1);//將張三與小狗關聯起來（所屬關係）
        M.feed(p1);//通過呼叫張三的的feed方法來喂小狗
        M.setPet(p2);//將張三與小貓關聯起來（現在不養小狗了，養小貓了）
        M.feed(p2);//通過呼叫張三的的feed方法來喂小貓
    }
}

------------------------------------
輸出結果：

狗在吃主人喂的狗糧
貓在吃主人喂的貓糧

Process finished with exit code 0

隨筆：

1.引數列表：引數的個數，引數的種類，引數的順序（不以引數名為準），不包括引數名；

2.向上轉型：指的是將子類引用資料型別轉換為父類引用資料型別（類比自動型別轉換）；

3.向下轉型：指的是將父類引用資料型別轉換為子類引用資料型別（類比強制型別轉換）；

---

由於博主目前還沒有將 Java-SE 的知識都學完，所以有些地方可能說的有些片面，若前輩們能夠指點一二就更好了 （～￣(OO)￣)ブ