面向物件編程三?特性 --封裝、繼承、多型

• 封裝
• 繼承
• 多型
• 一道簡單的面試題

封裝

把客觀事物封裝成抽象的類，并且類可以把自己的資料和方法只讓可信的類或者物件操作，對不可信的進行資訊隱藏，封裝是面向物件的特征之一，是物件和類概念的主要特性，

通俗的說，一個類就是一個封裝了資料以及操作這些資料的代碼的邏輯物體，在一個物件內部，某些代碼或某些資料可以是私有的，不能被外界訪問，
通過這種方式，物件對內部資料提供了不同級別的保護，以防止程式中無關的部分意外的改變或錯誤的使用了物件的私有部分，但是如果?個類沒有提供給外界訪問的?法，那么這個類也沒有什么意義了，

我們來看一個常見的 類，比如：Student

public class Student implements Serializable {
    
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

將物件中的成員變數進行私有化，外部程式是無法訪問的，對外提供了訪問的方式，就是set和get方法，
而對于這樣一個物體物件，外部程式只有賦值和獲取值的權限，是無法對內部進行修改

繼承

繼承 就是子類繼承父類的特征和行為，使得子類物件（實體）具有父類的實體域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為，
在 Java 中通過 extends 關鍵字可以申明一個類是從另外一個類繼承而來的，一般形式如下：

class 父類 {
}
 
class 子類 extends 父類 {
}

繼承概念的實作方式有二類：實作繼承與介面繼承，

實作繼承是指直接使用基類的屬性和方法而無需額外編碼的能力
介面繼承是指僅使用屬性和方法的名稱、但是子類必須提供實作的能力
一般我們繼承基本類和抽象類用 extends 關鍵字，實作介面類的繼承用 implements 關鍵字，

注意點：

通過繼承創建的新類稱為“子類”或“派生類”，被繼承的類稱為“基類”、“父類”或“超類”，
繼承的程序，就是從一般到特殊的程序，要實作繼承，可以通過“繼承”（Inheritance）和“組合”（Composition）來實作，
子類可以擁有父類的屬性和方法，
子類可以擁有自己的屬性和方法, 即?類可以對?類進?擴展，
子類可以重寫覆寫父類的方法，
JAVA 只支持單繼承，即一個子類只允許有一個父類，但是可以實作多級繼承，及子類擁有唯一的父類，而父類還可以再繼承，

使用implements關鍵字可以變相的使java具有多繼承的特性，使用范圍為類繼承介面的情況，可以同時繼承多個介面（介面跟介面之間采用逗號分隔），

# implements 關鍵字

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

值得留意的是： 關于父類私有屬性和私有方法的繼承 的討論
這個網上 有大量的爭論，我這邊以Java官方檔案為準：
With the use of the extends keyword, the subclasses will be able to inherit all the properties of the superclass except for the private properties of the superclass.
子類不能繼承父類的私有屬性（事實），但是如果子類中公有的方法影響到了父類私有屬性，那么私有屬性是能夠被子類使用的，

官方檔案 明確說明： private和final不被繼承，但從記憶體的角度看的話：父類private屬性是會存在于子類物件中的，

通過繼承的方法(比如，public方法)可以訪問到父類的private屬性

如果子類中存在與父類private方法簽名相同的方法，其實相當于覆寫

個人覺得文章里的一句話很贊，我們不可能完全繼承父母的一切（如性格等），但是父母的一些無法繼承的東西卻仍會深刻的影響著我們，

多型

同一個行為具有多個不同表現形式或形態的能力就是 多型，網上的爭論很多，筆者個人認同網上的這個觀點：多載也是多型的一種表現，不過多型主要指運行時多型
Java 多型可以分為 多載式多型和重寫式多型:

-多載式多型，也叫編譯時多型，編譯時多型是靜態的，主要是指方法的多載，它是根據引數串列的不同來區分不同的方法，通過編譯之后會變成兩個不同的方法，在運行時談不上多型，也就是說這種多型再編譯時已經確定好了，
-重寫式多型，也叫運行時多型，運行時多型是動態的,主要指繼承父類和實作介面時，可使用父類參考指向子類物件實作，這個就是大家通常所說的多型性，
這種多型通過動態系結（dynamic binding）技術來實作，是指在執行期間判斷所參考物件的實際型別，根據其實際的型別呼叫其相應的方法，也就是說，只有程式運行起來，你才知道呼叫的是哪個子類的方法， 這種多型可通過函式的重寫以及向上轉型來實作，

多型存在的三個必要條件:

1. 繼承
2. 重寫
3. 父類參考指向子類物件：Parent p = new Child();

我們一起來看個例子，仔細品讀代碼，就明白了：

@SpringBootTest
class Demo2021ApplicationTests {

    class Animal {
        public void eat(){
            System.out.println("動物吃飯！");
        }
        public void work(){
            System.out.println("動物可以幫助人類干活！");
        }
    }

    class Cat extends Animal {
        public void eat() {
            System.out.println("吃魚");
        }
        public void sleep() {
            System.out.println("貓會睡懶覺");
        }
    }

    class Dog extends Animal {
        public void eat() {
            System.out.println("吃骨頭");
        }
    }

    @Test
    void contextLoads() {
        //part1
        Cat cat_ = new Cat();
        cat_.eat();
        cat_.sleep();
        cat_.work();

        //part2
        Animal cat=new Cat();
        cat.eat();
        cat.work();
        cat.sleep();//此處編譯會報錯，

        Animal dog=new Dog();
        dog.eat();//結果為：吃骨頭，此處呼叫子類的同名方法，
        
        //part3
        //如果想要呼叫父類中沒有的方法，則要向下轉型，這個非常像"強轉"
        Cat cat222 = (Cat)cat;        // 向下轉型（注意，如果是(Cat)dog 則會報錯）
        cat222.sleep();        //結果為:貓會睡懶覺， 可以呼叫 Cat 的 sleep()
    }



}

我們來看上面part1部分：

Cat cat_ = new Cat();
cat_.eat();
cat_.sleep();
cat_.work();

結果：

吃魚
貓會睡懶覺，
動物可以幫助人類干活！

cat_.work(); 這處繼承了父類Animal的方法，還是很好理解的
我們接著看part2：

Animal cat=new Cat();
cat.eat();
cat.work();
cat.sleep();//此處編譯會報錯，

Animal dog=new Dog();
dog.eat();//結果為：吃骨頭，此處呼叫子類的同名方法，

這塊就比較特殊了，我們一句句來看
Animal cat=new Cat(); 像這種這個 父類參考指向子類物件，這種現象叫做："向上轉型",也被稱為多型的參考，
cat.sleep();這句 編譯器會提示 編譯報錯， 表明：當我們當子類的物件作為父類的參考使用時，只能訪問子類中和父類中都有的方法，而無法去訪問子類中特有的方法
值得注意的是：向上轉型是安全的，但是缺點是：一旦向上轉型，子類會丟失的子類的擴展方法，其實就是 子類中原本特有的方法就不能再被呼叫了，所以cat.sleep()這句會編譯報錯，

cat.eat();這句的結果列印：吃魚，程式這塊呼叫我們Cat定義的方法，
cat.work();這句的結果列印：動物可以幫助人類干活！ 我們上面Cat類沒有定義work方法，但是卻使用了父類的方法，這是不是很神奇，其實此處調的是父類的同名方法
Animal dog=new Dog();dog.eat();這句的結果列印為：吃骨頭，此處呼叫子類的同名方法，
由此我們可以知道當發生向上轉型，去呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去呼叫子類的同名方法，如果子類沒有同名方法，會再次去調父類中的該方法

我們現在知道了 向上轉型時會丟失子類的擴展方法，哎，但我們就是想找回來，這可咋辦？
向下轉型可以幫助我們，找回曾經失去的

我們來看part3:

    Cat cat_real = (Cat)cat;  //注意 此處的cat 對應上面父類Animal，可不是子類
    cat_real.sleep(); 

Cat cat = (Cat)cat; cat222.sleep(); 這個向下轉型非常像"強轉"，
列印的結果：貓會睡懶覺，此處又能呼叫了 子類Cat 的 sleep()方法了，

一道簡單的面試題

我們再來看一道有意思的題，來強化理解

public class Main {
    
    static class Animal{
        int weight = 10;

        public void print() {
            System.out.println("this Animal Print:" + weight);
        }

        public Animal() {
            print();
        }
    }

    static class Dog extends Animal {
        int weight = 20;

        @Override
        public void print() {
            System.out.println("this Dog Print:" + weight);
        }

        public Dog() {
            print();
        }
    }

    public static void main(String[] args) {
        Dog dog = new Dog();

        System.out.println("---------------");
        Animal dog222 = new Dog();
        Dog dog333 =  (Dog)dog222;
        
        System.out.println("---------------");
        Dog dog444 = (Dog)new Animal();

    }
}

執行結果：

this Dog Print:0
this Dog Print:20
---------------
this Dog Print:0
this Dog Print:20
---------------
this Animal Print:10
Exception in thread "main" java.lang.ClassCastException: com.zj.Main$Animal cannot be cast to com.zj.Main$Dog
at com.zj.Main.main(Main.java:15)

做對了嘛，不對的話，復制代碼去idea中debug看看

我們先看第一部分
Dog dog = new Dog();
程式內部的執行順序：

1. 先 初始化 父類Animal 的屬性 int weight=10
2. 然后 呼叫父類Animal的構造方法,執行print()
3. 實際呼叫子類Dog的print()方法,列印：this Dog Print:0，由于此時的子類屬性weight 并未初始化
4. 初始化 子類Dog 的屬性 int weight=20
5. 呼叫 子類Dog的構造方法，執行print()
6. 實際呼叫當前類的print()方法，列印this Dog Print:20

其中有幾處我們需要注意一下：實體化子類dog，程式會去默認優先實體化父類，即子類實體化時會隱式傳遞Dog的this呼叫父類構造器進行初始化作業，這個和JVM的雙親委派機制有關，這里就不展開講了，先挖個坑，以后再來填??，
當程式呼叫父類Animal的構造方法時，會隱式傳遞Dog的this,類似于：

Dog dog = new Dog(this);

static class Animal{
  public Animal(this) {
      print(this);//子類又把print()給重寫了
  }
}

static class Dog extends Animal {
  public Dog(this) {
      print(this);//此時子類的 屬int weight 被沒有初始化默認為0
  }
}

這塊其實和JVM的虛方法表有關，這又是一個大坑，以后慢慢填??，
我們接著看第2部分
Animal dog222 = new Dog();這句是向上轉型，程式加載順序和第一部分Dog dog = new Dog();是一樣的，都是實體化類的程序
Dog dog333 = (Dog)dog222;這個是向下轉型，并沒有呼叫類構造器，這塊等會和第3部分結合講

最后我們來看下第3部分Dog dog444 = (Dog)new Animal();這句先實體化Andimal類，它沒有父類，就直接實體化當前類，列印this Animal Print:10，然后(Dog)表示向下轉型，但是為啥運行會報ClassCastException 例外呢?且第2部分Dog dog333 = (Dog)dog222;卻沒有問題?
我們可以發現，向下轉型可以讓子類找回其獨有的方法 但是向下轉型是不安全的，實作 向下轉型 前需要先實作 向上轉型，

很感謝你能看到最后，如果喜歡的話，歡迎關注點贊收藏轉發，謝謝！更多精彩的文章

標籤：Java

上一篇：應用啟動加速-并發初始化spring bean

下一篇：Java連接資料庫(增刪改查)