一，前言
今天總結一下關於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基礎一定要掌握並熟記，因為這與我們的實際開發密切相關，好的編碼習慣才能鑄就好的產品，才能被社會認可。
以上總結均是自己學習所得，如有不適之處，還請留言（郵箱）指教。
感謝閱讀！