理解面向對象編程及面向對象編程語言的關鍵就是理解其四大特性：封裝、抽象、繼承、多態。不過，對於這四大特性，光知道它們的定義是不夠的，我們還要知道每個特性存在的意義和目的，以及它們能解決哪些編程問題 ...
理解面向對象編程及面向對象編程語言的關鍵就是理解其四大特性：封裝、抽象、繼承、多態。不過，對於這四大特性，光知道它們的定義是不夠的，我們還要知道每個特性存在的意義和目的，以及它們能解決哪些編程問題。
封裝（Encapsulation）
首先，我們來看封裝特性。封裝也叫作信息隱藏或者數據訪問保護。類通過暴露有限的訪問介面，授權外部僅能通過類提供的方式（或者叫函數）來訪問內部信息或者數據。這句話怎麼理解呢？我們通過一個簡單的例子來解釋一下。下麵這段代碼是金融系統中一個簡化版的虛擬錢包的代碼實現。在金融系統中，我們會給每個用戶創建一個虛擬錢包，用來記錄用戶在我們的系統中的虛擬貨幣量。
public class Wallet {
private String id;
private long createTime;
private BigDecimal balance;
private long balanceLastModifiedTime;
// ...省略其他屬性...
public Wallet() {
this.id = IdGenerator.getInstance().generate();
this.createTime = System.currentTimeMillis();
this.balance = BigDecimal.ZERO;
this.balanceLastModifiedTime = System.currentTimeMillis();
}
public String getId() { return this.id; }
public long getCreateTime() { return this.createTime; }
public BigDecimal getBalance() { return this.balance; }
public long getBalanceLastModifiedTime() { return this.balanceLastModifiedTime; }
public void increaseBalance(BigDecimal increasedAmount) {
if (increasedAmount.compareTo(BigDecimal.ZERO) < 0) {
throw new InvalidAmountException("...");
}
this.balance.add(increasedAmount);
this.balanceLastModifiedTime = System.currentTimeMillis();
}
public void decreaseBalance(BigDecimal decreasedAmount) {
if (decreasedAmount.compareTo(BigDecimal.ZERO) < 0) {
throw new InvalidAmountException("...");
}
if (decreasedAmount.compareTo(this.balance) > 0) {
throw new InsufficientAmountException("...");
}
this.balance.subtract(decreasedAmount);
this.balanceLastModifiedTime = System.currentTimeMillis();
}
}
從代碼中，我們可以發現，Wallet 類主要有四個屬性（也可以叫作成員變數），也就是我們前面定義中提到的信息或者數據。其中，id 表示錢包的唯一編號，createTime 表示錢包創建的時間，balance 表示錢包中的餘額，balanceLastModifiedTime 表示上次錢包餘額變更的時間。
我們參照封裝特性，對錢包的這四個屬性的訪問方式進行了限制。調用者只允許通過下麵這六個方法來訪問或者修改錢包里的數據。
-
String getId()
-
long getCreateTime()
-
BigDecimal getBalance()
-
long getBalanceLastModifiedTime()
-
void increaseBalance(BigDecimal increasedAmount)
-
void decreaseBalance(BigDecimal decreasedAmount)
之所以這樣設計，是因為從業務的角度來說，id、createTime 在創建錢包的時候就確定好了，之後不應該再被改動，所以，我們並沒有在 Wallet 類中，暴露 id、createTime 這兩個屬性的任何修改方法，比如 set 方法。而且，這兩個屬性的初始化設置，對於 Wallet 類的調用者來說，也應該是透明的，所以，我們在 Wallet 類的構造函數內部將其初始化設置好，而不是通過構造函數的參數來外部賦值。
對於錢包餘額 balance 這個屬性，從業務的角度來說，只能增或者減，不會被重新設置。所以，我們在 Wallet 類中，只暴露了 increaseBalance() 和 decreaseBalance() 方法，並沒有暴露 set 方法。對於 balanceLastModifiedTime 這個屬性，它完全是跟 balance 這個屬性的修改操作綁定在一起的。只有在 balance 修改的時候，這個屬性才會被修改。所以，我們把 balanceLastModifiedTime 這個屬性的修改操作完全封裝在了 increaseBalance() 和 decreaseBalance() 兩個方法中，不對外暴露任何修改這個屬性的方法和業務細節。這樣也可以保證 balance 和 balanceLastModifiedTime 兩個數據的一致性。
封裝特性的定義講完了，我們再來看一下，封裝的意義是什麼？它能解決什麼編程問題？
如果我們對類中屬性的訪問不做限制，那任何代碼都可以訪問、修改類中的屬性，雖然這樣看起來更加靈活，但從另一方面來說，過度靈活也意味著不可控，屬性可以隨意被以各種奇葩的方式修改，而且修改邏輯可能散落在代碼中的各個角落，勢必影響代碼的可讀性、可維護性。比如某個同事在不瞭解業務邏輯的情況下，在某段代碼中“偷偷地”重設了 wallet 中的 balanceLastModifiedTime 屬性，這就會導致 balance 和 balanceLastModifiedTime 兩個數據不一致。
除此之外，類僅僅通過有限的方法暴露必要的操作，也能提高類的易用性。如果我們把類屬性都暴露給類的調用者，調用者想要正確地操作這些屬性，就勢必要對業務細節有足夠的瞭解。而這對於調用者來說也是一種負擔。相反，如果我們將屬性封裝起來，暴露少許的幾個必要的方法給調用者使用，調用者就不需要瞭解太多背後的業務細節，用錯的概率就減少很多。這就好比，如果一個冰箱有很多按鈕，你就要研究很長時間，還不一定能操作正確。相反，如果只有幾個必要的按鈕，比如開、停、調節溫度，你一眼就能知道該如何來操作，而且操作出錯的概率也會降低很多。
抽象（Abstraction)
講完了封裝特性，我們再來看抽象特性。封裝主要講的是如何隱藏信息、保護數據，而抽象講的是如何隱藏方法的具體實現，讓調用者只需要關心方法提供了哪些功能，並不需要知道這些功能是如何實現的。
在面向對象編程中，我們常藉助編程語言提供的介面類（比如 Java 中的 interface 關鍵字語法）或者抽象類（比如 Java 中的 abstract 關鍵字語法）這兩種語法機制，來實現抽象這一特性。
對於抽象這個特性，我舉一個例子來進一步解釋一下。
public interface IPictureStorage {
void savePicture(Picture picture);
Image getPicture(String pictureId);
void deletePicture(String pictureId);
void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo);
}
public class PictureStorage implements IPictureStorage {
// ...省略其他屬性...
@Override
public void savePicture(Picture picture) { ... }
@Override
public Image getPicture(String pictureId) { ... }
@Override
public void deletePicture(String pictureId) { ... }
@Override
public void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo) { ... }
}
在上面的這段代碼中，我們利用 Java 中的 interface 介面語法來實現抽象特性。調用者在使用圖片存儲功能的時候，只需要瞭解 IPictureStorage 這個介面類暴露了哪些方法就可以了，不需要去查看 PictureStorage 類里的具體實現邏輯。
實際上，抽象這個特性是非常容易實現的，並不需要非得依靠介面類或者抽象類這些特殊語法機制來支持。換句話說，並不是說一定要為實現類（PictureStorage）抽象出介面類（IPictureStorage），才叫作抽象。即便不編寫 IPictureStorage 介面類，單純的 PictureStorage 類本身就滿足抽象特性。
之所以這麼說，那是因為，類的方法是通過編程語言中的“函數”這一語法機制來實現的。通過函數包裹具體的實現邏輯，這本身就是一種抽象。調用者在使用函數的時候，並不需要去研究函數內部的實現邏輯，只需要通過函數的命名、註釋或者文檔，瞭解其提供了什麼功能，就可以直接使用了。比如，我們在使用 C 語言的 malloc() 函數的時候，並不需要瞭解它的底層代碼是怎麼實現的。
抽象有時候會被排除在面向對象的四大特性之外，當時我賣了一個關子，現在我就來解釋一下為什麼。
抽象這個概念是一個非常通用的設計思想，並不單單用在面向對象編程中，也可以用來指導架構設計等。而且這個特性也並不需要編程語言提供特殊的語法機制來支持，只需要提供“函數”這一非常基礎的語法機制，就可以實現抽象特性、所以，它沒有很強的“特異性”，有時候並不被看作面向對象編程的特性之一。
抽象特性的定義講完了，我們再來看一下，抽象的意義是什麼？它能解決什麼編程問題？
實際上，如果上升一個思考層面的話，抽象及其前面講到的封裝都是人類處理複雜性的有效手段。在面對複雜系統的時候，人腦能承受的信息複雜程度是有限的，所以我們必須忽略掉一些非關鍵性的實現細節。而抽象作為一種只關註功能點不關註實現的設計思路，正好幫我們的大腦過濾掉許多非必要的信息。
除此之外，抽象作為一個非常寬泛的設計思想，在代碼設計中，起到非常重要的指導作用。很多設計原則都體現了抽象這種設計思想，比如基於介面而非實現編程、開閉原則（對擴展開放、對修改關閉）、代碼解耦（降低代碼的耦合性）等。我們在講到後面的內容的時候，會具體來解釋。
換一個角度來考慮，我們在定義（或者叫命名）類的方法的時候，也要有抽象思維，不要在方法定義中，暴露太多的實現細節，以保證在某個時間點需要改變方法的實現邏輯的時候，不用去修改其定義。舉個簡單例子，比如 getAliyunPictureUrl() 就不是一個具有抽象思維的命名，因為某一天如果我們不再把圖片存儲在阿裡雲上，而是存儲在私有雲上，那這個命名也要隨之被修改。相反，如果我們定義一個比較抽象的函數，比如叫作 getPictureUrl()，那即便內部存儲方式修改了，我們也不需要修改命名。
繼承（Inheritance)
學習完了封裝和抽象兩個特性，我們再來看繼承特性。如果你熟悉的是類似 Java、C++ 這樣的面向對象的編程語言，那你對繼承這一特性，應該不陌生了。繼承是用來表示類之間的 is-a 關係，比如貓是一種哺乳動物。從繼承關係上來講，繼承可以分為兩種模式，單繼承和多繼承。單繼承表示一個子類只繼承一個父類，多繼承表示一個子類可以繼承多個父類，比如貓既是哺乳動物，又是爬行動物。
繼承特性的定義講完了，我們再來看，繼承存在的意義是什麼？它能解決什麼編程問題？
繼承最大的一個好處就是代碼復用。假如兩個類有一些相同的屬性和方法，我們就可以將這些相同的部分，抽取到父類中，讓兩個子類繼承父類。這樣，兩個子類就可以重用父類中的代碼，避免代碼重覆寫多遍。不過，這一點也並不是繼承所獨有的，我們也可以通過其他方式來解決這個代碼復用的問題，比如利用組合關係而不是繼承關係。
如果我們再上升一個思維層面，去思考繼承這一特性，可以這麼理解：我們代碼中有一個貓類，有一個哺乳動物類。貓屬於哺乳動物，從人類認知的角度上來說，是一種 is-a 關係。我們通過繼承來關聯兩個類，反應真實世界中的這種關係，非常符合人類的認知，而且，從設計的角度來說，也有一種結構美感。
繼承的概念很好理解，也很容易使用。不過，過度使用繼承，繼承層次過深過複雜，就會導致代碼可讀性、可維護性變差。為了瞭解一個類的功能，我們不僅需要查看這個類的代碼，還需要按照繼承關係一層一層地往上查看“父類、父類的父類……”的代碼。還有，子類和父類高度耦合，修改父類的代碼，會直接影響到子類。
所以，繼承這個特性也是一個非常有爭議的特性。很多人覺得繼承是一種反模式。我們應該儘量少用，甚至不用。關於這個問題，在後面講到“多用組合少用繼承”這種設計思想的時候，我會非常詳細地再講解，這裡暫時就不展開講解了。
多態（Polymorphism）
學習完了封裝、抽象、繼承之後，我們再來看面向對象編程的最後一個特性，多態。多態是指，子類可以替換父類，在實際的代碼運行過程中，調用子類的方法實現。對於多態這種特性，純文字解釋不好理解，我們還是看一個具體的例子。
public class DynamicArray {
private static final int DEFAULT_CAPACITY = 10;
protected int size = 0;
protected int capacity = DEFAULT_CAPACITY;
protected Integer[] elements = new Integer[DEFAULT_CAPACITY];
public int size() { return this.size; }
public Integer get(int index) { return elements[index];}
//...省略n多方法...
public void add(Integer e) {
ensureCapacity();
elements[size++] = e;
}
protected void ensureCapacity() {
//...如果數組滿了就擴容...代碼省略...
}
}
public class SortedDynamicArray extends DynamicArray {
@Override
public void add(Integer e) {
ensureCapacity();
int i;
for (i = size-1; i>=0; --i) { //保證數組中的數據有序
if (elements[i] > e) {
elements[i+1] = elements[i];
} else {
break;
}
}
elements[i+1] = e;
++size;
}
}
public class Example {
public static void test(DynamicArray dynamicArray) {
dynamicArray.add(5);
dynamicArray.add(1);
dynamicArray.add(3);
for (int i = 0; i < dynamicArray.size(); ++i) {
System.out.println(dynamicArray.get(i));
}
}
public static void main(String args[]) {
DynamicArray dynamicArray = new SortedDynamicArray();
test(dynamicArray); // 列印結果：1、3、5
}
}
多態這種特性也需要編程語言提供特殊的語法機制來實現。在上面的例子中，我們用到了三個語法機制來實現多態。
-
第一個語法機制是編程語言要支持父類對象可以引用子類對象，也就是可以將 SortedDynamicArray 傳遞給 DynamicArray。
-
第二個語法機制是編程語言要支持繼承，也就是 SortedDynamicArray 繼承了 DynamicArray，才能將 SortedDyamicArray 傳遞給 DynamicArray。
-
第三個語法機制是編程語言要支持子類可以重寫（override）父類中的方法，也就是 SortedDyamicArray 重寫了 DynamicArray 中的 add() 方法。
通過這三種語法機制配合在一起，我們就實現了在 test() 方法中，子類 SortedDyamicArray 替換父類 DynamicArray，執行子類 SortedDyamicArray 的 add() 方法，也就是實現了多態特性。
接下來，我們先來看如何利用介面類來實現多態特性。我們還是先來看一段代碼
public interface Iterator {
String hasNext();
String next();
String remove();
}
public class Array implements Iterator {
private String[] data;
public String hasNext() { ... }
public String next() { ... }
public String remove() { ... }
//...省略其他方法...
}
public class LinkedList implements Iterator {
private LinkedListNode head;
public String hasNext() { ... }
public String next() { ... }
public String remove() { ... }
//...省略其他方法...
}
public class Demo {
private static void print(Iterator iterator) {
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
public static void main(String[] args) {
Iterator arrayIterator = new Array();
print(arrayIterator);
Iterator linkedListIterator = new LinkedList();
print(linkedListIterator);
}
}
多態特性講完了，我們再來看，多態特性存在的意義是什麼？它能解決什麼編程問題？
多態特性能提高代碼的可擴展性和復用性。為什麼這麼說呢？我們回過頭去看講解多態特性的時候，舉的第二個代碼實例（Iterator 的例子）。在那個例子中，我們利用多態的特性，僅用一個 print() 函數就可以實現遍歷列印不同類型（Array、LinkedList）集合的數據。當再增加一種要遍歷列印的類型的時候，比如 HashMap，我們只需讓 HashMap 實現 Iterator 介面，重新實現自己的 hasNext()、next() 等方法就可以了，完全不需要改動 print() 函數的代碼。所以說，多態提高了代碼的可擴展性。
如果我們不使用多態特性，我們就無法將不同的集合類型（Array、LinkedList）傳遞給相同的函數（print(Iterator iterator) 函數）。我們需要針對每種要遍歷列印的集合，分別實現不同的 print() 函數，比如針對 Array，我們要實現 print(Array array) 函數，針對 LinkedList，我們要實現 print(LinkedList linkedList) 函數。而利用多態特性，我們只需要實現一個 print() 函數的列印邏輯，就能應對各種集合數據的列印操作，這顯然提高了代碼的復用性。
除此之外，多態也是很多設計模式、設計原則、編程技巧的代碼實現基礎，比如策略模式、基於介面而非實現編程、依賴倒置原則、里式替換原則、利用多態去掉冗長的 if-else 語句等等。關於這點，在學習後面的章節中，你慢慢會有更深的體會。
重點回顧
今天的內容就講完了，我們來一起總結回顧一下，你需要重點掌握的幾個知識點。
1、關於封裝特性
封裝也叫作信息隱藏或者數據訪問保護。類通過暴露有限的訪問介面，授權外部僅能通過類提供的方式來訪問內部信息或者數據。它需要編程語言提供許可權訪問控制語法來支持，例如 Java 中的 private、protected、public 關鍵字。封裝特性存在的意義，一方面是保護數據不被隨意修改，提高代碼的可維護性；另一方面是僅暴露有限的必要介面，提高類的易用性。
2、關於抽象特性
封裝主要講如何隱藏信息、保護數據，那抽象就是講如何隱藏方法的具體實現，讓使用者只需要關心方法提供了哪些功能，不需要知道這些功能是如何實現的。抽象可以通過介面類或者抽象類來實現，但也並不需要特殊的語法機制來支持。抽象存在的意義，一方面是提高代碼的可擴展性、維護性，修改實現不需要改變定義，減少代碼的改動範圍；另一方面，它也是處理複雜系統的有效手段，能有效地過濾掉不必要關註的信息。
3、關於繼承特性
繼承是用來表示類之間的 is-a 關係，分為兩種模式：單繼承和多繼承。單繼承表示一個子類只繼承一個父類，多繼承表示一個子類可以繼承多個父類。繼承主要是用來解決代碼復用的問題。
4、關於多態特性
多態是指子類可以替換父類，在實際的代碼運行過程中，調用子類的方法實現。多態可以提高代碼的擴展性和復用性，是很多設計模式、設計原則、編程技巧的代碼實現基礎。
