轉載請注明文章出處：https://blog.csdn.net/zengsao/article/details/112848632

前言

對于熟悉Java語言的小伙伴來說，Java的三大特征都是我們耳熟能詳的，其分別是封裝，繼承和多型，我們在開發的程序中經常就用到了這三大特征，但大家是否認真思考過這三大特征呢，封裝的必要性是什么？繼承能夠給我們帶來什么便利，多型的底層又是如何實作的，本篇博文將帶大家詳解了解！！！

一、封裝

1、封裝的概念

??封裝性是面向物件編程的核心思想，指的就是將描述某種物體的資料和基于這些數的操作集合到一起，隱藏于類的內部，形成一個封裝體，外部程式不被允許直接訪問，只能通過該類提供的特定的方法來實作對隱藏資訊的操作和訪問，也就是說：不僅
要隱藏物件的資訊
同時也要留出訪問的介面

2、封裝的好處

??只能通過規定方法訪問資料
??隱藏類的實作細節
??方便修改實作
??方便加入控制陳述句　　

3、封裝的實作

??欄位：使用 private 修飾符修飾
??方法：也是一種封裝，封裝的實作的細節
??類： 也是一種封裝，封裝了多個方法和其他資訊

public class test02 {
    public static void main(String[] args) {
       Person person = new Person();
       person.age = 18;//可以直接訪問
       person.name = "zhangsan";//可以直接訪問
       person.setIdcard("123456789123456789");//通過相應介面，即setter方法才能訪問
       System.out.println(person.age+" "+person.getAge());
       System.out.println(person.name+" "+person.getName());
       System.out.println(person.getIdcard());
    }

}
class Person{
    public String name;
    public int age;
    /*private修飾符修飾的欄位，外部不能直接訪問
     即指向該物體的參考不能通過xxx.idcard的方式訪問該欄位*/
    private String idcard;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getIdcard() {
        return idcard;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    public void setIdcard(String idcard) {
        //通過在setter方法中添加條件控制陳述句來校驗賦值的合法性
        if(idcard.toCharArray().length == 18){//這里的校驗只是為了說明
            this.idcard = idcard;
        }else{
            System.out.println("身份證格式錯誤");
        }
    }
}

二、繼承

1、繼承的概念

??繼承是面向物件最顯著的一個特性，繼承是從已有的類中派生出新的類，新的類能吸收已有類的資料屬性和行為，并能擴展新的能力，Java語言中的類只支持單繼承，如一個類只能有一個父類，而介面支持多繼承，Java中多繼承的功能是通過介面（interface）來間接實作的，繼承關系是傳遞的，若類C繼承類B，類B繼承類A（多層繼承），則類C既有從類B那里繼承下來的屬性與方法，也有從類A那里繼承下來的屬性與方法，還可以有自己新定義的屬性和方法，繼承來的屬性和方法盡管是隱式的，但仍是類C的屬性和方法，


繼承如下 3 點請記住：

1. ?類擁有?類物件所有的屬性和?法（包括私有屬性和私有?法），但是?類中的私有屬性
   和?法?類是?法訪問，只是擁有，
2. ?類可以擁有??屬性和?法，即?類可以對?類進?擴展，
3. ?類可以???的?式實作?類的?法，

2、繼承的好處

??子類可以直接訪問父類中的非私有的屬性和行為
??提高代碼的復用性，
??讓類與類之間產生了關系，是多型的前提

3、繼承的實體

public class test03 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.color+" "+dog.legs);
        dog.color = "黑色";
        dog.legs = 4;
        System.out.println(dog.color+" "+dog.legs);
        /*   1.
        * 注意背景關系繼承而來屬性的值，因為在new時構造器給父類的屬性賦值，
        * 所以子類繼承而來的也是同樣的值，但子類繼承來的值是自己獨有一份的,看第三個注釋
        * */
        Dog dog1 = new Dog();
        System.out.println(dog1.color+" "+dog1.legs);
        dog1.eat();
        dog1.sleep();
        /*    2.
        子類繼承了父類的work方法，也是獨有一份，但沒有重寫，
        所以其方法的執行指向父類的work方法，詳細原理將在文章多型中介紹
        */
        dog1.work();
        /*    3.
        *上文再次new子類（從而再次給父類屬性賦值），
        *但這里再次呼叫dog繼承而來的屬性，值不變，證明繼承而來的的確是子類獨有一份
        */
        System.out.println(dog.color+" "+dog.legs);
        /*運行結果
        * 黃色 4
          黑色 4
          黃色 4
          狗吃屎
          狗睡覺
          動物作業
          黑色 4
          * * */
    }
}
class Animal{
    int legs;
    String color;

    Animal(String color,int legs){
        this.color = color;//this代表當前物件，誰呼叫就是誰
        this.legs = legs;
    }
    public void eat(){
        System.out.println("動物吃飯");
    }
    protected void sleep(){
        System.out.println("動物睡覺");
    }
    public void work(){
        System.out.println("動物作業");
    }

    private void method(){
        System.out.println("特有方法");
    }

}
class Dog extends Animal{
    /*
    * 當new子類的物件時，子類的構造器會默認會呼叫父類的構造器
    * 就算沒寫，編譯器也會幫我們添加，
    * 當父類沒有默認的無參構造器時，便會發生編譯錯誤，
    *解決這個編譯錯誤有三種辦法：
    *1.在父類Person中添加默認構造方法，子類Student會隱式呼叫父類的默認構造方法，
    *2.在子類Studen構造方法添加super陳述句，顯式呼叫父類構造方法，super陳述句必須是第一條陳述句，
    *3.在子類Studen構造方法添加this陳述句，顯式呼叫當前物件其他構造方法(this(引數型別 引數...);)，
    * this陳述句必須是第一條陳述句，
    * */
    Dog(){
        super("黃色",4);//super代表父類（可以看作父類物件的參考）
    }

    @Override
    public void eat(){
        System.out.println("狗吃屎");
    }
    /*重寫的條件：
    * 1.權限修飾符大于等于不包括private
    * 2.回傳值型別相同
    * 3.方法名和引數串列相同
    *
    *  */
    @Override
    public void sleep(){//public大于protected
        System.out.println("狗睡覺");
    }

    /*私有方法不能繼承

    @Override
    private void method(){

    }*/

}

靜態代碼塊、構造代碼塊，構造方法的執行順序：
父類靜態代碼塊→子類靜態代碼塊→父類構造代碼塊→父類構造方法→子類構造代碼塊→子類構造方法

三、多型

1、多型的概念

??多型就是指程式中定義的參考變數所指向的具體型別和通過該參考變數發出的方法呼叫在編程時并不確定，而是在程式運行期間才確定，即一個參考變數倒底會指向哪個類的實體物件，該參考變數發出的方法呼叫到底是哪個類中實作的方法，必須在由程式運行期間才能決定，

2、多型的條件

??繼承：在多型中必須存在有繼承關系的子類和父類
??重寫：子類對父類中某些方法進行重新定義
??向上轉型：父類的參考指向子類物件

3、多型的表現形式

??方法的多載
??方法的重寫
??介面的實作

4、底層的體現

1）方法的多載：
方法的多載跟jvm虛擬機中的靜態分派密切相關，舉個梨子：

public class Test01 {
    static class Human{}
    static class Man extends Human{}
    static class Woman extends Human{}
    public void sayhello(Human human){
        System.out.println("hello human");
    }
    public void sayhello(Man man){
        System.out.println("hello man");
    }
    public void sayhello(Woman woman){
        System.out.println("hello woman");
    }
    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        Test01 test = new Test01();
        test.sayhello(man);
        test.sayhello(woman);
    }
}
/*運行結果
hello human
hello human
* */

??在Human man = new Man();這條代碼中，我們將“Human”稱為變數”human“的的靜態型別，也叫做外觀型別，后面的“Man”則是變數的實際型別，兩者的區別在于靜態型別的變化僅僅在使用時發生（即我們寫這條代碼的時候），變數本身的靜態型別不會被改變，并且最終的靜態型別是在編譯期確定的，而實際型別變化的結果在運行期確定，編譯器在編譯程式的時候并不知道一個物件的實際型別是什么，
??上面的代碼中，test.sayhello(引數)已經確定方法的接收者是test，后面具體使用哪個多載版本，就完全取決于傳入引數的數量和型別了，上面的代碼其型別都是Human，我們可以看到，在這個程序中，我們是依賴靜態型別來定位方法的執行版本的，這樣的分派動作稱為靜態分派，發生在編譯期間，也可以稱為編譯時多型，


2)方法的重寫：
介紹：
重寫發?在運?期，是?類對?類的允許訪問的?法的實作程序進?重新撰寫，

1. 回傳值型別、?法名、引數串列必須相同，拋出的例外范圍?于等于?類，訪問修飾符范圍?于等于?類，子類方法回傳值型別小于等于父類方法回傳值型別（回傳值是void和基本資料型別時，則必須相等，如果時參考型別，則要小于等于父類），
2. 如果?類?法訪問修飾符為 private/final/static 則?類就不能重寫該?法，但是被 static 修飾
   的?法能夠被再次宣告，
3. 構造?法?法被重寫
   
   方法的重寫跟jvm虛擬機的動態分派密切相關，同樣的，舉個栗子：

public class Test02 {
    static class Human{
        public void say(){
            System.out.println("我是人類");
        }
        public void specialmethod(){
            System.out.println("父類不被重寫的方法");
        }
    }
    static class Man extends Human{
        @Override
        public void say(){
            System.out.println("我是男人");
        }
        public void dowhat(){
            System.out.println("男人賺錢養家");
        }

    }
    static class Woman extends Human{
        @Override
        public void say(){
            System.out.println("我是女人");
        }
        public void dowhat(){
            System.out.println("女人相夫教子");
        }
    }
    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        man.say();
        woman.say();
        man.specialmethod();
        woman.specialmethod();
        //human.dowhat();編譯期報錯，向上轉型會丟失子類特有的方法
        Man man1 = (Man)man;//利用向下轉型可以彌補向上轉型的缺陷
        man1.dowhat();
    }
}
/*運行結果
* 我是男人
我是女人
父類不被重寫的方法
父類不被重寫的方法
男人賺錢養家
* */

??導致靜態型別同樣是Human的兩次方法呼叫結果不同的是兩個參考的實際型別不同，jvm虛擬機又是如何根據實際型別來動態分派執行不同的版本的呢？我們通過查看main方法的位元組碼指令來解釋，

??上圖中第1行到第八行是new兩個物件的程序，第10行跟第12行是方法呼叫指令，這兩條指令是一摸一樣的，但是其執行的結果卻是不一樣的，原因需要從invokevirtual指令的多型查找程序說起，在此之前，讓我們先看一下jvm虛擬機中的方法區（jdk8開始，方法區只是一概念，其實作在本地記憶體中，稱為元空間）中子類的虛方法表：



拓展：
??方法表的實作如下：
??父類的方法比子類的方法先得到決議，即父類的方法相比子類的方法位于表的前列，

??表中每項對應于一個方法，索引到實際方法的實作代碼上，如果子類重寫了父類中某個方法的代碼，則該方法第一次出現的位置的索引更換到子類的實作代碼上，而不會在方法表中出現新的項，

??JVM 運行時，當代碼索引到一個方法時，是根據它在方法表中的偏移量來實作訪問的，（第一次執行到呼叫指令時，會執行決議，將符號索引替換為對應的直接索引），

??由于 invokevirtual 呼叫的方法在對應的類的方法表中都有固定的位置，直接索引的值可以用偏移量來表示，（符號索引決議的最終目的是完成直接索引：物件方法和物件變數的呼叫都是用偏移量來表示直接索引的）


從圖中我們可以看出：
??1.子類中從父類繼承而來的方法都是自己獨享一份的

??2.如果某個方法在子類中沒有被重寫，那子類的虛方法表里面的地址入口和父類相同方法的地址入口是一致的，都指向父類的實作入口(這點在圖中沒有體現)

??3.如果子類中重寫了該方法，子類方法表中的地址將會替換成指向子類實作版本的入口，

??4.并且能夠看出同樣簽名的方法在方法表中的偏移量是一樣的，這個偏移量僅僅是說Man方法表中的繼承自Object類的方法、繼承自Human類的方法的偏移量與Object和Human類中的同樣方法的偏移量是一樣的，與woman是沒有什么關系的，


??了解了上面的知識，我們再來解釋一下invokevirtual指令的執行程序：
1）根據#9在常量池中得到方法呼叫的符號參考
2）在Human類的方法表中查找say()方法，如果找到了，則將方法say()在方法表中的索引專案（index） 記錄到Human類的常量池中第9個常量表中(常量池決議)，
3）在執行invokevirtual指令前，Man物件或者Woman物件的參考就已將被壓入運算元堆疊中，invokevirtual指令會根據這個參考找到在堆中的物件進而找到在方法區中這個類的虛方法表
4）這時，在通過前面的index找到相應索引位置的方法入口地址，如果這個方法被子類重寫了，則指向子類自己的方法代碼執行，如果沒被重寫，則指向父類的方法代碼執行，這個時候，相同索引值的好處就體現出來了，
??綜上所訴，兩次呼叫的中的相同的符號參考決議到了不同的直接參考上，這個程序就是java語言中重寫的本質，


3）介面的實作:
??介面的實作跟方法重寫的情況類似，我們試著把上面方法重寫的代碼改寫成是介面的實作，如下

public class Test03 {
    static interface Human{
        public void say();

    }
    static class Man implements Human {
        @Override
        public void say(){
            System.out.println("我是男人");
        }
        public void dowhat(){
            System.out.println("男人賺錢養家");
        }

    }
    static class Woman implements Human {
        @Override
        public void say(){
            System.out.println("我是女人");
        }
        public void dowhat(){
            System.out.println("女人相夫教子");
        }
    }
    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        man.say();
        woman.say();
        //man.dowhat();編譯期報錯，向上轉型會丟失子類特有的方法
        Man man1 = (Man)man;//利用向下轉型可以彌補向上轉型的缺陷
        man1.dowhat();
    }
    /*運行結果
    * 我是男人
      我是女人
      男人賺錢養家
    * */
}

再來看一下main方法的位元組碼指令：

??我們重點看第17跟23行，可以發現，除了方法指令的不同（忽略類名），其他基本沒什么不同，那么invokeinterface指令跟invokevirtual指令在執行時有什么不同呢？
??子類實作介面中的方法在方法表中的位置不是固定的，因此不能依照索引值來直接定位，Java 對于介面方法的呼叫是采用搜索方法表的方式，如，要在Man的方法表中找到say()方法，必須搜索Man的整個方法表，
??因為每次介面呼叫都要搜索方法表，所以從效率上來說，介面方法的呼叫總是慢于類方法的呼叫的，
??

5、多型的應用

??說了怎么多，我們最后來看一下多型應用的一個例子，感受一下多型帶給我們的方便！

import java.util.ArrayList;

public class Test04 {
    public static void main(String[] args) {
        phoneBag phoneBag = new phoneBag();//new一個手機袋
        //往手機袋里面放手機
        phoneBag.add(new Vivo());
        phoneBag.add(new iphone());
        phoneBag.add(new OPPO());
        //獲得手機袋里面的手機數量
        System.out.println(phoneBag.getNum());
        //利用向下轉型運行各個手機的獨立功能
        Vivo vivo = (Vivo)phoneBag.getPhone(0);
        vivo.use();
        iphone iphone1 =  (iphone)phoneBag.getPhone(1);
        iphone1.use();
        OPPO oppo = (OPPO)phoneBag.getPhone(2);
        oppo.use();
        /*運行結果
           3
          我使用vivo手機拍照
          我使用蘋果手機玩游戲
          我使用OPPO手機看視頻
        * */

    }

}
interface Phone{
}
class Vivo implements Phone{
    public void use() {
        System.out.println("我使用vivo手機拍照");
    }
}
class iphone implements Phone{
    public void use() {
        System.out.println("我使用蘋果手機玩游戲");
    }
}
class OPPO implements Phone{
    public void use() {
        System.out.println("我使用OPPO手機看視頻");
    }
}
class phoneBag{
    ArrayList<Phone> phones = new ArrayList<>();
    //往手機袋里裝手機
    public void add(Phone phone){
        phones.add(phone);
    }
    //獲得手機的數量
    public int getNum(){
        return phones.size();
    }
    //根據索引取得手機
    public Phone getPhone(int index){
        return phones.get(index);
    }
}

??在上面的例子中，比如我有個土豪，他有很多部手機，各部手機各司其職，我們申明三個手機類，各個手機類有自己的使用方法，并且都實作了手機大類這個介面，除此之外，我們申明了一個手機袋類，在里面new了一個ArrayList集合來存放手機，泛型使用Phone，為什么要使用Phone這個介面作為泛型呢，你想想，我們這里只是三部手機，如果這個土豪有錢沒地花，買了20部呢，難道我們要申明20個不同型別的集合來存放他們嗎？這樣代碼量太高了，
??很多時候，我們需要把很多種類的實體物件，全部扔到一個集合，因此我們實作同個介面，用父類的參考將這些實際型別放在同一個集合中，用到的時候再取出來用，經過了這個程序，子類實體已經賦值給了父類參考（即完成了向上轉型），但很遺憾的丟失了子類擴展的方法，
??解決這個問題的方式就是向下轉型（向下轉型前一定要有向上轉型），利用向下轉型我們就可以使用子類獨有的方法，

結語

本文詳細地介紹了java的三大特征，篇幅最長的是多型，閱讀多型時需要有jvm虛擬機一定的基礎，希望能夠幫助到大家，也歡迎大家對內容指正，