[Java基礎篇]Java的三大特性：封裝、繼承、多態

一、封裝

封裝隱藏了類的內部實現機制，可以在不影響使用的情況下改變類的內部結構，同時也保護了數據。對外界而已它的內部細節是隱藏的，暴露給外界的只是它的訪問方法。
對於封裝而言，一個對象它所封裝的是自己的屬性和方法，所以它是不需要依賴其他對象就可以完成自己的操作。
1、封裝的步驟：
· 使用private 關鍵字來修飾成員變量
· 對需要訪問的成員變量，提供對應的一對getXxx 方法和setXxx 方法。
2、private的含義
· private 是一個權限修飾符，代表最小權限。
· 可以修飾成員變量 和成員方法 。
· 被private 修飾後的成員變量和成員方法，只在本類中才能訪問。
3、使用封裝的優點

（1）良好的封裝能夠減少耦合。
（2）類內部的結構可以自由修改。
（3）可以對成員進行更精確的控制。
（4）隱藏信息，實現細節。

一般情況下封裝實現如下：

private String name;
    private int age;
    public void setName(String n){
        name=n;
    }
    public void setAge(int a){
        age=a;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }

如果出現參數變量與成員變量同名的話，setXxx()函數就賦值不了，所以我們要對setXxx()函數要做出以下改變，getXxx函數不變。
封裝優化–this關鍵字（this代表所在類的當前對象的引用（地址值），即對象自己的引用。）

private String name;
    private int age;
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }

封裝優化–構造方法（當一個對象被創建時候，構造方法用來初始化該對象，對象的成員變量賦初值）

private String name;
private int age;
public Student(){///無參構造方法
}
public Student(String name,int age){
this.name=name;
this.age=age;
}

二、繼承

多個類中存在相同屬性和行爲時，將這些內容抽取到一個單獨的一個類中，那麼多個類無需再定義這些屬性和行爲，只要繼承那一個類即可。
​​​​​​​​​​​​​​​​​​​​​​​​​​

1、什麼是繼承？（所有類默認繼承Object，作爲父類）

就是子類繼承父類的屬性和行爲，使得子類對象具有與父類相同的屬性、相同的行爲。子類可以直接訪問父類中的非私有的屬性和行爲。
·繼承的特點： Java只支持單繼承，不支持多繼承。
·運用繼承的優點： 提高代碼的複用性；類與類之間產生了關係，是多態的前提。
·繼承的格式：

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

2、繼承後的特點：

（1）成員變量
1）成員變量不重名：子類父類中沒有出現重名的成員變量，訪問不影響。

class fu{
   int num = 5;
}
class zi extends fu{
   int num1 = 6;
   public void show(){
      System.out.println(num);
      System.out.println(num1);
   }
}
///測試類
zi z = new zi();
z.show();///輸出5 6

2）成員變量重名：子類父類中出現重名的成員變量，訪問受影響。輸出按照就近原則。

class fu{
   int num = 5;
}
class zi extends fu{
   int num = 6;
   public void show(){
      System.out.println(num);
      System.out.println(num);
   }
}
///測試類
zi z = new zi();
z.show();///輸出6 6

fu類的成員變量是非私有的，子類可以直接訪問；否則，就不可以直接訪問。

（2）成員方法
1）成員方法不重名，沒有影響。

class fu{
   public void show(){
     System.our.println("fu類中的show方法執行");
   }
}
class zi extends fu{
    public void show1(){
      System.out.println("zi 類中的show1方法執行");
    }
}

///測試類
zi z = new zi();
z.show();
z.show1();

（2）成員方法重名–重寫（返回值、方法名、參數列表都相同的覆蓋效果），按照就近原則（只執行子類的方法）
注意：子類方法覆蓋父類方法，必須要保證權限大於等於父類權限；子類方法覆蓋父類方法，返回值類型、函數名和參數列表都要一模一樣。
（3）構造方法（構造器）

構造器的特點：

· 構造器與類同名
· 每個類可以有一個以上的構造器
· 構造器可以有0、1、或多個參數
· 構造器沒有返回值
· 構造器總是伴隨着new操作一起調用

1）構造方法的名字是與類名一致的。所以無法繼承父類構造方法的。
2）構造方法的作用是初始化成員變量的，所以子類的初始化過程中，必須先執行初始化動作。子類的構造方法默認有一個super()，表示調用父類的構造方法，父類成員變量初始化後，纔可以給子類使用。

class fu{
    fu(){///父類構造方法
     System.out.println("fu()!!!");
    }
}
class zi extends fu{
   super();///調用父類的構造方法
   System.out.println("zi()!!!");
}

三、多態

1、什麼是多態？
多態就是指通過不同的事物，可以體現出來的不同的形態。（如：動物：狗、貓、豬…。酒：五糧酒、江南春、酒鬼酒）
· 使用多態的前提：
（1）繼承或實現
（2）方法的重寫（重寫：方法名、以及參數列表都一樣）
（3）父類引用指向子類對象（向上轉型）
· 多態定義的格式：

父類類型 變量名 = new 子類對象;
變量名.方法名;

fu f = new zi();
f.method();

注意：當使用多態方式調用多態時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，執行的是子類重寫後的方法。
2、多態的轉型
多態的轉型：向上轉型和向下轉型。
（1）向上轉型： 多態本身是子類類型向父類型向上轉換的過程，這個過程是默認的。
（2）向下轉型： 父類類型向子類類型向下轉換的過程，這個過程是強制的。

子類類型 變量名 = (子類類型) 父類變量名
Animal a = new Cat();///向上轉換
Cat c = (Cat) a;///向下轉換

爲什麼添加了向下轉型？
多態本身不能調用子類擁有的方法，而父類沒有的方法。所以想要調用子類特有的方法，必須做向下轉型。
3、多態的實現方式
（1）基於繼承實現的多態
基於繼承的實現機制主要表現在父類和繼承該父類的一個或多個子類對某些方法的重寫，多個子類對同一方法的重寫可以表現出不同的行爲。

package lianxi;

class Animal{
     public void eat(){
         System.out.println("eat!!!");
     }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("cat吃魚");
    }
    public void catskill(){
        System.out.println("cat會抓老鼠");
    }
}
class Dog extends Animal{
     public void eat(){
         System.out.println("dog吃骨頭");
     }
     
     public void dogskill(){
         System.out.println("dog會看家");
    }
}
public class test {
    public static void main(String [] args){
        Animal a = new Cat();///向上轉型
        a.eat();
        
        Cat cat = (Cat) a;///向下轉型
        cat.catskill();
    }
}

上面的代碼只是打印Cat的技能而已，如果我們還想打印Dog的技能，我們可能會想到直接加：

Dog dog = (Dog) a;///a已經創建爲Cat類型了
dog.dogskill();

不就行了嗎，這會導致編譯錯誤的，運行拋出ClassCastException，類型轉換異常！這是因爲明明創建了Cat類型對象，，運行是當然不能轉換成Dog對象的。但是Java中提供了一個instanceof關鍵字，給引用類型的校驗，格式如下：

變量名 instanceof 數據類型
如果變量屬於該數據類型，返回true。
如果變量不屬於該數據類型，返回false。

把上面的代碼改一下的核心代碼：

Animal a = new Cat();///向上轉型
        a.eat();
       if(a instanceof Cat){
           Cat cat = (Cat) a;///向下轉型
           cat.catskill();
       }
       else if(a instanceof Dog){///如果a類型爲Dog()類型的話
           Dog dog = (Dog) a;
           dog.dogskill();
       }

（2）基於接口實現的多態
在接口的多態中，指向接口的引用必須是指定這實現了該接口的一個類的實例程序，在運行時，根據對象引用的實際類型來執行對應的方法。
參考黑馬程序員的資料，定義USB接口，實現筆記本類，鼠標類，鍵盤類:

package lianxi;

import java.security.Key;

interface USB{
    void open();///開啓功能
    void close();///關閉功能
}
class Mouse implements USB{///鼠標類
    public void open(){
        System.out.println("鼠標開啓，紅燈亮起來！");
    }
    public void close(){
        System.out.println("鼠標關閉，紅燈熄滅！");
    }
    public void click(){///鼠標特有功能，父類沒有，子類擁有
        System.out.println("鼠標單擊！");
    }
}
class  KeyBoard implements USB{///鍵盤類
     public void open(){
       System.out.println("鍵盤開啓，橙燈亮起！");
     }
     public void close(){
       System.out.println("鍵盤關閉，橙燈熄滅！");
     }
     public void type(){///鍵盤特有的功能
       System.out.println("鍵盤打字！");
     }
}

class Laptop{///筆記本類
    public void run(){
      System.out.println("筆記本運行");
    }
    public void useUSB(USB usb){
        if(usb!=null){
            usb.open();
            if(usb instanceof Mouse){
                Mouse mouse = (Mouse) usb;
                mouse.click();
            }else if(usb instanceof KeyBoard){
                KeyBoard keyBoard = (KeyBoard) usb;
                keyBoard.type();
            }
            usb.close();
        }
    }

    public void shutDown(){
      System.out.println("筆記本關閉");
    }
}
public class test {
    public static void main(String [] args) {
      Laptop it = new Laptop();
      it.run();///筆記本運行

      USB usb = new Mouse();
      it.useUSB(usb);///使用鼠標

      KeyBoard keyBoard = new KeyBoard();
      it.useUSB(keyBoard);

      it.shutDown();///筆記本關閉
    }
}
/*
筆記本運行
鼠標開啓，紅燈亮起來！
鼠標單擊！
鼠標關閉，紅燈熄滅！
鍵盤開啓，橙燈亮起！
鍵盤打字！
鍵盤關閉，橙燈熄滅！
筆記本關閉
 */

四、參考資料

1、黑馬程序員的PDF資料
2、https://www.cnblogs.com/chenssy/p/3372798.html
3、