一，前言

今天總結一下關于JAVA的三大特性，封裝，繼承，多態。其實關于三大特性對于從事編程人員來說都是基本的了，畢竟只要接觸Java這些都是先要認識的，接下來就系統總結一下。

二，封裝

? 先來說說特性之一：封裝

2.1，什么是封裝

? 封裝（Encapsulation）是面向對象方法的重要原則，就是把對象的屬性和操作（或服務）結合為一個獨立的整體，并盡可能隱藏對象的內部實現細節。

• 將類的某些信息隱藏在類的內部，不允許外部程序進行直接的訪問調用。
• 通過該類提供的方法來實現對隱藏信息的操作和訪問。
• 隱藏對象的信息。
• 留出訪問的對外接口。

? 舉個比較通俗的例子，比如我們的USB接口。如果我們需要外設且只需要將設備接入USB接口中，而內部是如何工作的，對于使用者來說并不重要。而USB接口就是對外提供的訪問接口。

? 說了這么多，那為什么使用封裝？

2.2，封裝的特點

• 對成員變量實行更準確的控制。
• 封裝可以隱藏內部程序實現的細節。
• 良好的封裝能夠減少代碼之間的耦合度。
• 外部成員無法修改已封裝好的程序代碼。
• 方便數據檢查，有利于保護對象信息的完整性，同時也提高程序的安全性。
• 便于修改，體高代碼的可維護性。

2.3，封裝的使用

• 使用private修飾符，表示最小的訪問權限。
• 對成員變量的訪問，統一提供setXXX，getXXX方法。
• 下面請看一個Student實體對象類：
• public class Student implements Serializable { private Long id; private String name; private Integer sex; 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; } public Integer getSex() { return sex; } public void setSex(Integer sex) { this.sex = sex; } }
• 分析：對于上面的一個實體對象，我想大家都已經很熟悉了。將對象中的成員變量進行私有化，外部程序是無法訪問的。但是我們對外提供了訪問的方式，就是set和get方法。
• ? 而對于這樣一個實體對象，外部程序只有賦值和獲取值的權限，是無法對內部進行修改，因此我們還可以在內部進行一些邏輯上的判斷等，來完成我們業務上的需要。
• ? 到這里應該就明白封裝對于我們的程序是多么重要。下面再來說說繼承的那點事。
• 三，繼承3.1，什么是繼承
• ? 繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。當然，如果在父類中擁有私有屬性(private修飾)，則子類是不能被繼承的。
• 3.2，繼承的特點
• 1，關于繼承的注意事項：
• ? 只支持單繼承，即一個子類只允許有一個父類，但是可以實現多級繼承，及子類擁有唯一的父類，而父類還可以再繼承。
• ? 子類可以擁有父類的屬性和方法。
• ? 子類可以擁有自己的屬性和方法。
• ? 子類可以重寫覆蓋父類的方法。
• 2，繼承的特點：
•  提高代碼復用性。 父類的屬性方法可以用于子類。 可以輕松的定義子類。 使設計應用程序變得簡單。 3.3，繼承的使用
• ? 1，在父子類關系繼承中，如果成員變量重名，則創建子類對象時，訪問有兩種方式。
• a，直接通過子類對象訪問成員變量
• ? 等號左邊是誰，就優先使用誰，如果沒有就向上找。
• b，間接通過成員方法訪問成員變量
• 該方法屬于誰，誰就優先使用，如果沒有就向上找。
• public class FU { int numFU = 10; int num = 100; public void method(){ System.out.println("父類成員變量："+numFU); } public void methodFU(){ System.out.println("父類成員方法!"); } } public class Zi extends FU{ int numZi = 20; int num = 200; public void method(){ System.out.println("子類成員變量："+numFU); } public void methodZi(){ System.out.println("子類方法！"); } } public class ExtendDemo { public static void mAIn(String[] args) { FU fu = new FU(); // 父類的實體對象只能調用父類的成員變量 System.out.println("父類：" + fu.numFU); // 結果：10 Zi zi = new Zi(); System.out.println("調用父類：" + zi.numFU); // 結果：10 System.out.println("子類：" + zi.numZi); // 結果：20 /** 輸出結果為200，證明在重名情況下，如果子類中存在則優先使用， * 如果不存在則去父類查找，但如果父類也沒有那么編譯期就會報錯。 */ System.out.println(zi.num); // 結果：200 /** * 通過成員方法調用成員變量 */ zi.method(); // 結果：10 } }
• 2，同理：
• ? 成員方法也是一樣的，創建的對象是誰，就優先使用誰，如果沒有則直接向上找。
  ? 注意事項：
• ? 無論是成員變量還是成員方法，如果沒有都是向上父類中查找，絕對不會向下查找子類的。
• 3，在繼承關系中，關于成員變量的使用：
• ? 局部成員變量：直接使用
  ? 本類成員變量：this.成員變量? 父類成員變量：super.父類成員變量
• int numZi = 10; public void method() { int numMethod = 20; System.out.println(numMethod); // 訪問局部變量 System.out.println(this.numZi); // 訪問本類成員變量 System.out.println(super.numFu); // 訪問本類成員變量 } 3.4，重寫，重載
• ? 重寫(override)
• ? 是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！
• class Animal{ public void move(){ System.out.println("動物行走！"); } } class Dog extends Animal{ public void move(){ System.out.println("狗可以跑和走"); } } public class TestDog{ public static void main(String args[]){ Animal a = new Animal(); // Animal 對象 Animal b = new Dog(); // Dog 對象 a.move();// 執行 Animal 類的方法 b.move();//執行 Dog 類的方法 } }
• ? 重寫的規則：
• ? 1，參數列表必須與被重寫方法相同。
• ? 2，訪問權限不能比父類中被重寫的方法的訪問權限更低（public>protected>(default)>private）。
• ? 3，父類成員的方法只能被它的子類重寫。
• ? 4，被final修飾的方法不能被重寫。
• ? 5，構造方法不能
• 重載(overload)
• ? 是在一個類里面，方法名字相同，而參數不同。返回類型可以相同也可以不同。每個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。
• ? 最常用的地方就是構造器的重載。

   public class Overloading {
       public int test(){
           System.out.println("test1");
           return 1;
       }
       public void test(int a){
           System.out.println("test2");
       }   
       //以下兩個參數類型順序不同
       public String test(int a,String s){
           System.out.println("test3");
           return "returntest3";
       }   
       public String test(String s,int a){
           System.out.println("test4");
           return "returntest4";
       }    
       public static void main(String[] args){
           Overloading o = new Overloading();
           System.out.println(o.test());
           o.test(1);
           System.out.println(o.test(1,"test3"));
           System.out.println(o.test("test4",1));
       }
   }

? 重載規則：

? 1，被重載的方法必須改變參數列表（參數個數或者類型不一樣）。

? 2，被重載的方法可以改變返回類型。

? 3，被重載的方法可以改變訪問修飾符。

3.5，this，super關鍵字

super()關鍵字的用法
? 1，子類的成員方法中，訪問父類的成員變量。

? 2，子類的成員方法中，訪問父類的成員方法。
3，子類的構造方法中，訪問父類的構造方法。

this關鍵字用法：
? 1，本類成員方法中，訪問本類的成員變量。
? 2，本類成員方法中，訪問本類的另一個成員方法。
3，本類的構造方法中，訪問本類的另一個構造方法。
? 注意：

• this關鍵字同super一樣，必須在構造方法的第一個語句，且是唯一的。
• this與super不能同時存在。

3.6，構造器

? 繼承關系中，父子類構造方法的訪問特點：
? 1，在子類構造方法中有一個默認隱含的super();調用，因此一定是先調用父類構造方法，再調用子類構造方法。
? 2，子類構造可以通過super();調用父類的重載構造。(重載)
? 3，super();的父類調用構造方法，必須在子類構造中的第一行，就是第一個;號結束的元素，并且只能調用一次。

3.7，關于繼承的注意事項：

? 1，Java語言是單繼承的，一個子類只能有唯一一個父類
? 2，Java語言可以是多級繼承，一個子類有一個父類，一個父類還可以有一個父類。
? 3，一個子類只有一個父類，但是一個父類可以有多個子類。

四，多態

4.1，什么是多態

? 多態是同一個行為具有多個不同表現形式或形態的能力。

4.2，多態的特點

? 1，消除類型之間的耦合關系，實現低耦合。

? 2，靈活性。

? 3，可擴充性。

? 4，可替換性。

4.3，多態的體現形式

• 繼承
• 父類引用指向子類
• 重寫
• ? 注意：在多態中，編譯看左邊，運行看右邊

   public class MultiDemo {
       public static void main(String[] args) {
           // 多態的引用，就是向上轉型
           Animals dog = new Dog();
           dog.eat();
           
           Animals cat = new Cat();
           cat.eat();
           
           // 如果要調用父類中沒有的方法，則要向下轉型
           Dog dogDown = (Dog)dog;
           dogDown.watchDoor();
   
       }
   }
   class Animals {
       public void eat(){
           System.out.println("動物吃飯！");
       }
   }
   class Dog extends Animals{
       public void eat(){
           System.out.println("狗在吃骨頭！");
       }
       public void watchDoor(){
           System.out.println("狗看門！");
       }
   }
   class Cat extends Animals{
       public void eat(){
           System.out.println("貓在吃魚！");
       }
   }

4.4，向上轉型

1，格式：父類名稱 對象名 = new 子類名稱(); 
      含義：右側創建一個子類對象，把它當作父類來使用。
      注意：向上轉型一定是安全的。
      缺點：一旦向上轉型，子類中原本特有的方法就不能再被調用了。	

五，接口

? 最后，關于接口方面的細節，不同版本之間的區別。

問題描述：

? 現在接口中需要抽取一個公有的方法，用來解決默認方法中代碼重復的問題。
? 但是這個共有的方法不能讓實現類實現，所以應該設置為私有化。

在JDK8之后：

? 1，default修飾，接口里允許定義默認的方法，但默認方法也可以覆蓋重寫。
? 2，接口里允許定義靜態方法。

在JDK9之后：

? 1，普通私有方法，解決多個默認方法之間代碼重復的問題。
? 2，靜態私有化，解決多個靜態方法之間代碼重復問題。
? 接口的注意事項：
? 1，不能通過接口的實現類對象去調用接口中的靜態方法。
? 正確語法：接口名稱調用靜態方法。

接口當中的常量的使用：

? 1，接口當中定義的常量：可以省略public static final。
? 2，接口當中定義的常量：必須進行賦值。
? 3，接口當中定義的常量：常量的名稱要全部大寫，多個名稱之間使用下劃線進行分割。

使用接口的注意事項：

? 1，接口是沒有靜態代碼塊或者構造方法
? 2，一個類的直接父類是唯一的，但是一個類可以同時實現多個接口。
? 3，如果實現類沒有覆蓋重寫接口中所有的抽象方法，那么實現類就必須是一個抽象類
? 4，如果實現類中實現多個接口，存在重復的抽象方法，那么只需要覆蓋重寫一次即可。
? 5，在Java中，如果實現類的直接繼承父類與實現接口發生沖突時，父類優先級高于接口。

接口之間的關系：

? 1，多個接口之間是繼承關系。
? 2，多個父接口當中默認方法如果重復，那么子接口必須進行默認方法的覆蓋重寫。

六，總結

? 關于Java的特性基本總結完畢，當然還有一些細節沒有完善。其實對于這些Java基礎一定要掌握并熟記，因為這與我們的實際開發密切相關，好的編碼習慣才能鑄就好的產品，才能被社會認可。