前言
大家好啊，我是湯圓，今天給大家帶來的是《Java中的三大特性 - 超詳細篇》，希望對大家有幫助，謝謝
這一節的內容可能有點多，大家可以選擇性的來看
簡介
Java的三大特性：封裝、繼承、多態
乍一聽，好像很高大上，其實當你真正用的時候，會發現高大上的還在后面呢。。。
熱身
在正式講解三大特性之前，先普及幾個知識
1. 訪問權限修飾符
Java中關於訪問權限的四個修飾符，表格如下
| private | friendly（默認） | protected | public | |
|---|---|---|---|---|
| 當前類訪問權限 | √ | √ | √ | √ |
| 包訪問權限 | × | √ | √ | √ |
| 子類訪問權限 | × | × | √ | √ |
| 其他類訪問權限 | × | × | × | √ |
其中比較尷尬的是protected修飾符，有點卡在中間，不上不下的感覺
因為它不適合用來修飾屬性
假設用它修飾屬性，那么任何一個人都可以通過繼承這個類，來直接訪問到這個類的屬性，從而破壞"封裝性"
2. 抽象類（abstract）
什么是抽象類？
抽象類就是用abstract修飾，且不能被直接初始化的類，但是可以通過子類來初始化
比如：Father father = new Son()
對應的，抽象方法就是用abstract修飾的方法
抽象方法是一種很特殊的方法，它沒有方法體，即方法實現代碼為空，比如abstract public void fun();
抽象方法一般在子類中進行實現，它就好像是在說：我不寫代碼，我只是聲明一個方法名，剩下的交給我的子孫后代（繼承類）去做
抽象類有一個很重要的特點：抽象類可以沒有抽象方法，但是如果一個類有抽象方法，那么這個類肯定是抽象類
為什么會有抽象類
解耦，使代碼結構更加清晰
因為抽象類不能被直接創建為對象，它只是作為一個通用接口來供別人實現和調用，所以這樣就使得抽象的代碼更加清晰（它只聲明方法，不實現方法）
就好比，老板和員工，老板負責分發任務，員工負責去具體的實現任務
好了，關於抽象類，先介紹到這里，更詳細的后面的章節再深入
3. 重載(overloading)和覆寫(overwriting)
重載和覆寫是兩個很容易混淆的概念
重載：同一個類中，一個方法的多種表現形式（參數類型不同，參數個數不同）
覆寫：繼承設計中，子類覆蓋父類的方法（也可以叫做重寫，不過這樣跟重載有點混淆，所以個人喜歡叫做覆寫）
他們之間的區別如下
| 重載 | 覆寫 | |
|---|---|---|
| 訪問權限 | 可以不同 | 可以不同（但是子類的可見性不能比父類的低） |
| 方法返回值 | 可以不同 | 相同 |
| 參數類型 | 不同（充分條件） | 相同 |
| 參數個數 | 不同（充分條件） | 相同 |
這里要注意幾點
- 覆寫時，子類的方法訪問權限不能低於父類，比如父類方法為public，那么子類也只能為public
- 重載時，訪問權限和方法返回值，不能作為用來判斷一個方法是否為重載的依據；只能說重載允許不同的訪問權限和返回值
覆寫示范
代碼示范如下，
// 覆寫一：正確示范
@Override
public void fun(){
System.out.println("son fun");
}
// 覆寫二：錯誤示范，訪問權限低了
@Override
private void fun(){
// 報錯：'fun()' in 'SonDemo' clashes with 'fun()' in 'Father'; attempting to assign weaker access privileges ('private'); was 'public'
System.out.println("son fun");
}
@Override這個是干嘛的？之前沒見過啊
這個修飾符用來說明這個方法是覆寫方法，不寫也可以，系統會自己識別方法是不是覆寫的
那為啥還要多此一舉呢？用系統默認的識別機制不好嗎？
要多此一舉；不好；
因為加了注解，代碼可讀性更高，代碼更加規范，別人看了代碼后，立馬就知道這個方法是覆寫方法
重載示范
重載用圖展示可能會更加清晰
圖示解釋：
參數類型和參數個數，只要滿足其一，就可以說這個方法被重載了
訪問權限和方法返回值用虛線框，是為了說明他們兩個只是重載的一個附加表現形式（可有可無），不能作為重載的判斷依據
下面用代碼演示下
// 基礎方法
public void fun1(int a){
}
// 重載一：參數個數不同
public void fun1(){
}
// 重載二：參數類型不同
public void fun1(float a){
}
// 重載三：錯誤示范，僅僅用訪問權限的不同來重載
private void fun1(int a){
// 編譯報錯：'fun1(int)' is already defined
}
// 重載四：錯誤示范，僅僅用返回值的不同來重載
public int fun1(int a){
// 編譯報錯：'fun1(int)' is already defined
return 0;
}
下面進入正文，開始順序介紹這三大特性
正文
1. 封裝（Encapsulation）
就是把類的屬性私有化(private修飾），再通過公有方法(public)進行訪問和修改
為什么要封裝呢？
-
追蹤變化：可以在set方法中，編寫代碼來追蹤屬性的改變記錄
public void setName(String name) { System.out.println("名字即將被修改"); System.out.println("舊名字：" + this.name); System.out.println("新名字：" + name); this.name = name; } -
修改底層實現：在修改屬性名時，不會影響外部接口對屬性的訪問
比如：name屬性改為firstName和lastName，name就可以在get方法中修改返回值為firstName+lastName，對外接口沒變化
// 修改前 private String name; public String getName() { return name; } // 修改后 private String firstName; private String lastName; // 方法名不用變，只是方法內容作了修改 public String getName() { return firstName + lastName; }
-
校驗數據：可以在set方法中，校驗傳來的數據是否符合屬性值的設定范圍，防止無效數據的亂入
public void setAge(int age) throws Exception { if(age>1000 || age<0){ throw new Exception("年齡不符合規范，0~1000"); } this.age = age; }
2. 繼承(Inheritance)
如果子類繼承了父類，那么子類就可以復用父類的方法和屬性，並且可以在此基礎上新增方法和屬性
這里要注意的一點是：Java是單繼承語言，即每個類只能有一個父類
這里還要普及一個常識：如果一個類沒有指定父類（即沒有繼承任何類），那么這個類默認繼承Object類
為什么要用繼承呢？
為了代碼復用，減少重復工作
單繼承不會太局限嗎？為啥不用多繼承？
因為多繼承會導致"致命方塊"問題（因為像撲克牌的方塊符號）
- 比如A同時繼承B和C，然后B和C各自繼承D
- B和C各自覆寫了D的fun方法
- 那這時A該調用哪個類的fun方法呢
下面用圖來說話
那為什么叫致命方塊，而不是致命三角形呢？那個D類好像是多余的
不多余
這個D類其實就是上面講到的抽象類的作用：將共有的部分fun()抽象出來（或者提供一個基礎的實現），然后子類分別去實現各自的，這也是多態的一種體現（下面會將多態）
如果沒有D類，那么B和C的fun()就會存在重復代碼，這時你可能就想要搞一個父類出來了，這個父類就是D類
那要怎么判斷繼承類設計得好不好呢？
通過is-a關系來判斷
is-a關系指的是一個是另一個的關系，男人是人（說得通），人是男人（一半說得通）
用is-a關系可以很好地體現你的繼承類設計的好還是壞
- 如果子類都可以說是一個父類，那么這個繼承關系設計的就很好（男人是人，is-a關系）
- 如果子類和父類只是包含或者引用的關系，那么這個繼承關系就很糟糕（貓是貓籠，包含關系）
有沒有什么辦法可以阻止類的繼承？就像private修飾符用來封裝屬性，其他人訪問不到一樣
有啊，final修飾符可以阻止類的繼承
這里重點講一下final修飾符
final可以用來修飾屬性、方法、類，表示他們是常量，不可被修改的
final修飾屬性：屬性是常量，必須在定義時初始化，或者構造函數中初始化
final修飾方法：方法不能被覆寫
final修飾類：類不能被繼承
說到final，有必要提一下內聯
內聯指的是，如果一個方法內容很短，且沒有被其他類覆寫時，方法名會被直接替換為方法內容
比如：final getName()這個方法可以內聯為name屬性
再比如：getSum(){return a+b},會直接被內聯為a+b
為什么會有內聯這個東西呢？
因為這樣可以提高效率（細節：CPU在處理方法調用的指令時，使用的分支轉移會擾亂預取指令的策略，這個比較底層，這里先簡單介紹，后面章節再深入）
那它有沒有什么缺點呢？
有，如果一個方法內容過長，又誤被當做內聯處理，那么就會影響性能
比如你的代碼多個地方都調用這個方法，那么你的代碼就會膨脹變得很大，從而影響性能
那有沒有辦法可以解決呢？
有，虛擬機的即時編譯技術
即時編譯會進行判斷，如果一個方法內容很長，且被多次調用，那么它會自動關閉內聯機制，防止代碼膨脹
3. 多態(Polymorphism)
字面理解，就是多種形態，在Java中，多態指的是，一個類可以有多種表現形態
多態主要是 用來創建可擴展的程序
像我們上面提到的繼承就是屬於多態的一種
還有一種就是接口（interface）
接口類一種是比抽象類更加抽象的類
因為抽象類起碼還可以實現方法，但是接口類沒得選，就只能定義方法，不能實現
不過從Java8開始，接口支持定義默認方法和靜態方法
接口的默認方法（default修飾符）和靜態方法（static修飾符)，會包含方法內容，這樣別人可以直接調用接口類的方法（后面章節再細講）
這樣你會發現接口變得很像抽象類了，不過接口支持多實現（即一個類可以同時實現多個類，但是一個類同時只能繼承一個類）
這樣一來，Java相當於間接地實現了多繼承
下圖說明繼承和實現的區別：單繼承，多實現
多態一般用在哪些場景呢？
場景很多，這里說兩個最常用的
- 場景一：方法的參數，即方法定義時，父類作為方法的形參，然后調用時傳入子類作為方法的實參
- 場景二：方法的返回值，即方法定義時，父類作為方法的返回值，然后在方法內部實際返回子類
代碼示范如下：
public class PolyphorismDemo {
public static void main(String[] args) {
PolyphorismDemo demo = new PolyphorismDemo();
//場景一：形參，將貓（子類）賦值給動物（父類）
demo.fun(new Cat());
//場景二：返回值，將貓賦值給動物
Animal animal = demo.fun2();
}
public void fun(Animal animal){
}
public Animal fun2(){
return new Cat();
}
}
class Animal{
}
class Cat extends Animal{
}
總結
其中還有很多知識點沒總結，太多了，看起來會不方便，所以其他的內容會陸續放到后面章節來講
這里先簡單列出來，比如：
- equals和hashcode的關系
- instanceof和getClass()的區別
- 靜態綁定和動態綁定
- Java8的默認方法和靜態方法
- 等等等
后記
最后，感謝大家的觀看，謝謝