OO
Java 是物件導向的（object-oriented）語言。物件導向近年來成為顯學，全新的程式語言幾乎都具備物件導向的特色，而舊的程式語言也紛紛在新版本中開始支援物件導向的特色。
所謂「物件導向的特色」，
指的是物件導向的三個機制，三者缺一不可，此三個機制分別為封裝（encapsulation）、繼承（inheritance）、多型（polymorphism）。我也喜歡把這三個機制稱為三個階段，以突顯出它們之間的次序性：沒有封裝就不可能會有繼承，沒有繼承就不可能會有多型。為了稱呼上的方便，我們常常將物件導向簡稱為 OO。
有一些程式語言常被誤認為是 OO 的語言，但其實不然。例如：Visual Basic 6 以及更早的版本只支援封裝，不支援繼承和多型，所以不可以被視為 OO 的語言。這種只支援封裝 的語言，只能被稱為 object-based 程式語言。但是 Visual Basic 7（也就是 Visual Basic.NET）開始支援繼承和多型，所以可以被視為 OO 的語言，因此威力大增，語言的複雜度也會大增，因為繼承和多型會帶來許多複雜的特質。
1.封裝（encapsulation）
關於封裝，你可以扮演兩種角色：
- 封裝者：封裝出一個類別（class），以供他人使用。
- 類別使用者：使用別人封裝出來的類別
程式員都是在這兩種角色之間不斷地轉換：一會兒封裝出一個類別，一會兒使用別人封裝好的類別。當一個類別使用者顯然比當一個封裝者簡單許多，只要透過 new 這個關鍵字來產生類別的 instance，即可使用。如果欲使用的是 class method/field，甚至連 new 都可以省了。既然當類別使用者比當封裝者來得簡單，我們自然是盡量使用既有的類別， 這樣就可以達到很高的再用性（reusability）。Java 平台提供了數千個已經封裝好的類別，我們可以直接拿來使用，這可以為我們省下許多時間。這些類別所形成的集合，就稱為 API。
查詢 Java API
J2SE 平台所具備的 API，就稱為 Core API（核心 API）。你可以在你的 Java 2 SDK 路徑下找到 docs/api/index.html，這就是 API 文件，從這裡，你就可以找到每個類別的用法（例如我們在 Hello 程式中使用的 System，就是一個類別）。畫面如下所示：
![clip_image002[6]](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEirjzuG2tl7ZbB82us92f53TmsPCz4Ol19FqSbgrkf5yyVbBN-OagtW3oUfquOyGDmpPkzKVDo3uQ5Nt01pFzDl70cHavjPu7b4gdsr4N8M7Pd_GTn3BxdrKmjTnaa4X8foFH6Ze0Ogctj5/?imgmax=800 "clip_image002[6]")
我很喜歡
把程式設計比喻成設計一個主機板。主機板的設計者不用一切從頭來，因為他們有許多 IC chip（晶片）可以使用（其中有一個 chip 為 CPU）。從市面上的各種 chip 中（SIS、Intel、VIA…），挑選出各種適合的 chip，再把這些 chip 全都放到主機板上適當的位置固定好，再把這些 chip 的接腳之間互相 連接起來就可以了。這麼一來，設計主機板的工作包含：
- 挑選 chip
- 應用這些 chip 來進行電路佈局（circuit layout）
寫程式很類似設計主機板，差異在於主機板是硬件，程式是軟件。
寫 Java 程式不用一切從頭來，因為我們有許多類別可以使用。從 Java Core API 的類別中， 挑選出各種你需要的類別，把這些類別用在你的程式中，程式中利用 Java 的關鍵字（keyword） 和算符（operator）將這些類別銜接起來就可以了。這麼一來，寫程式的工作包含：
- 挑選適當的類別
- 應用這些類別來完成程式
2.繼承（inheritance）
既有的 Java API 已經可以滿足我們大多數時候的需求，
但還是有些時候，我們希望有一個類別能提供特定的功能，但是 Java API 不提供這樣的類別。我們通常會找協力廠商（thirty party）購買這樣的類別。有許多軟體公司專門提供類別庫（class library），收納了許多好用的類別，例如繪製統計圖表（chart）的類別、產生報表（report）的類別、複雜科學計算的類別……等。你可以在 WWW 上找到許多這樣的產品。
如果沒有任何廠商提供完全符合你需求的類別，或者你根本不想增加成本購買 third party 的類別（這些類別通常都不單獨出售， 而是許多類別被包在一起成為類別庫，且售價不便宜），那麼你只好自己寫一個這樣的類別。
假設我們現在就有這樣的需求，需要設計一個類別。在下面的程式碼中，我們封裝出一個名為 ClassB 類別：
// code-1
class ClassB
{
int doThis() {
// ...
// ...很多、很多程式碼...
// ...
}
int doThat() {
// ...
// ...很多、很多程式碼...
// ...
}
}這時候，你發現有一個叫做 ClassA 的類別，也提供了 doThis() 和 doThat()，其中 ClassA 的 doThis() 完全就是 ClassB 的 doThis() 所需要的功能，但是 ClassA 的 doThat() 卻和 ClassB 的 doThat() 所需要的功能有一些小差異，
你希望 ClassB 的 doThat() 傳出值一定是大於等於零的整數。 你可以把 ClassA 拿來運用在 ClassB 中，將 code-1程式改寫如下：
// code-2
class ClassB {
ClassA a = new ClassA();
int doThis() {
return a.doThis();
}
int doThat() {
return Math.abs(a.doThat());
// Math.abs() 是取絕對值（正數）的意思
}
}code-2 的版本因為運用 ClassA，所以整個程式比 code-1 更精簡。
我們稱 ClassA 被嵌入（embed）到 ClassB 中，
ClassB 把 method 遞送給 ClassA 的 method 來處理。
如果 ClassA 除了具有 doThis() 和 doThat() 之外，還具有100 個 method， 分別叫做 method1() method2()、……、method100()，而且這100 個 method 每個都是 ClassB 想要具備的功能，那麼我們的 code-2 程式可以改寫如下：
// code-3
class ClassB {
ClassA a = new ClassA();
int doThis() {
return a.doThis();
}
int doThat() {
return Math.abs(a.doThat());
}
int method1() {
return a.method1();
}
int method2() {
return a.method2();
}
// ...一直重複類似的程式碼
int method100() {
return a.method100();
}
}這根本就是一場惡夢， 因為我們不斷地把 ClassB 的 methodX() 轉給 ClassA 的 methodX()。這個程式糟透了， 我們應該把它改成下面的版本：
// code-4
class ClassB extends ClassA{ //ClassB 繼承 ClassA
int doThat() {
return Math.abs(a.doThat());
}
}code-4 的版本用到繼承（inheritance）的技巧。
繼承也是封裝的一種，所以
語法和封裝很類似，唯一的差異是多了 extends 以及後面的 ClassA。extends 是 Java 的關鍵字，後面接著一個類別的名稱，用來表示繼承的來源。
以此例來說，我們稱 ClassA 是 ClassB 的父類別（parent class），或超類別（super class），或基底類別（base class）；
我們稱 ClassB 是 ClassA 的子類別（child class），或次類別（sub-class），或衍生類別（derived class）。
code-4 的寫法之所以比 code-3 簡潔，是因為 code-4 使用繼承。在 code-4 中，雖然 ClassB 本身只定義了一個 method，也就是 doThat() ，但是 ClassA 中的 method 也會被自動繼承過來。 換句話說，我們可以拿 ClassB 的對象來呼叫 ClassA 中定義的 method，如下例所示：
ClassB b = new ClassB();
b.doThis();
b.method1();
這就是
繼承的目的「之一」：達到程式碼的再用性（reusability）。ClassB 輕易地運用了 ClassA 的程式碼。
（繼承的另一個目的是：為多型做準備。）我主張繼承應該被視為一種特殊的封裝，因為
繼承只是一種「過程」，繼承的結果仍是封裝，一個全新的封裝。
在繼承的時候，如果子類別定義了和父類別完全相同名稱（包括參數、傳出值、修飾字）的 method，我們就說子類別的此 method 推翻（override）了父類別的同名 method。
從 code-4 的例子來看，ClassB 的 doThat() 推翻了 ClassA 的 doThat()。
請注意，在繼承的時候，不只 instance method 會被繼承，連 instance field、class field、class method 都會被繼承。
如果你不希望你所設計出來的類別被其他類別繼承，那麼你可以利用 final 來修飾此 class，如下所示：
// code-5
final class MyClass {
// ...
}如果你不希望你所設計出來的某個 method 被子類別推翻（override），那麼你可以利用 final 來修飾此 method，如下所示：
// code-6
class MyClass {
final int myMethod() {
// ...
}
}
在 Java 中，每個類別都會有父類別。
如果你沒有用 extends 關鍵字來指定父類別，那麼它的父類別就是 java.lang.Object， 例如：code-6 的程式其實等同於下面的程式：
// code-7
class MyClass extends java.lang.Object {
final int myMethod() {
// ...
}
}，因為：
- 它是唯一沒有父類別的類別
- Java 所有的類別都直接或間接地繼承了 java.lang.Object
請牢記下面三點：
- 每個類別（java.lang.Object 除外）一定有一個父類別
- 一個父類別可以有許多子類別
- 所有的類別都源自於 java.lang.Object
繼承的使用時機
認清繼承的使用時機很重要。如果存在某個類別（比方說 ClassA）， 其功能和我們的需求「差不多」，但有一些不同之處，那麼我們就「可以」 使用繼承的方式來設計一個類別（比方說 ClassB），以將 Class 的功能抄襲過來， 並進行「擴充」或「修改」。
「可以」使用繼承，不代表「一定要」使用繼承。 繼承也不見得全然都只有好處，沒有任何缺點。有些時候，兩個 class 之間的關係，用 association 的關係比用繼承的關係好。也就是說，有些時候我們不用 code-4 的版本，反而使用 code-2 的版本，因為這樣做有下列的好處：
- 在 code-2 中，a 可以被其他類使用；但在 code-4 中，則無法這麼做。
- 在 code-2 中，a 可以隨時被設定成別的物件；但在 code-4 中，則無法改變。
- ClassB 可以不提供部份的 method，例如：code-2 就不提供 method1()~method100()；
但在 code-4 中， ClassB 無法決定哪些 method/field 要繼承或不繼承。
特別注意：
繼承一定需要「擴充」或「修改」，如果不擴充也不修改，這樣的繼承就毫無意義可言。
所謂的擴充，指的是：子類別新定義父類別沒有的 method，以擴充功能；所謂的修改，指的是子類別提供 method 推翻父類別的同名 method。
3.多型（polymorphism）
關於多型（Polymorphism），一言以蔽之：
「當某變數的實際型態（actual type）和形式型態（formal type）不一致時，呼叫此變數的 method，一定會呼叫到「正確」的版本， 也就是實際型態的版本。」
從這句話，我們可以思索下面的問題：
- 為什麼實際型態和形式型態會不一致？
- 多型帶來時麼好處？
如果你能夠瞭解這兩點，你就能徹底瞭解多型。
學會多型之後，你不可以對多型有「錯誤的期待」。千萬要小心下面這兩點：
- 多型的機制只用在 method 上，不用在 field 上。
- 多型的機制只用在 instance method上，不用在 class method 上。
在本文章中，我也會對上述兩點提出明確的解釋。
為什麼實際型態和形式型態會不一致？
請看下面的例子：
因為 a 和 b 是基本型態（primitive type），而非 reference 型態，所以 a 的值會被複製一份到 b。在複製的過程中，a 的值原本是 32 bit 的 int，會被自動地擴充成（widen）64 bit 的 long，再指定（assign）給 b。正因為有擴充和複製，所以對於 b 來說，其實際型態（值的型態）和形式型態（宣告時的型態）都一樣是 long。
所有屬於基本型態的變數都類似如此，在設定其值的時候，會經歷擴充（或縮減）以及複製，製造出實際型態和形式型態一致的值。
但是 reference 型態可就不一樣了。請看下面的例子：
class ClassA {
void method1() {
System.out.println("method1() in ClassA");
}
void method2() {
System.out.println("method2() in ClassA");
}
}
class ClassB extends ClassA {
void method1() {
System.out.println("method1() in ClassB");
}
void method3() {
System.out.println("method3() in ClassB");
}
}
public class ClassC {
public static void main(String[] args) {
ClassA a = new ClassB();
a.method1(); // method1() in ClassB
a.method2(); // method2() in ClassA
a.method3(); // compile-time error
}
}對於 reference 型態來說，
使用指定算符（assignment operator）時， 只有記憶體位址會被複製，對象本身不會被複製，所以實際值並不會受到變寬或變窄的破壞。
我們在 ClassC 中，產生一個 ClassB 的對象，並將它設定給 a。但是 a 被宣告成 ClassA 型態，所以
a 的實際型態（ClassB）和形式型態（ClassA）並不一致。 在這樣的情況下，呼叫 a 的 method1() 會執行到哪一個版本？實際型態的版本或形式型態的版本？
正確答案是實際型態（ClassB）的版本。這就是多型！
讓我們再看一次文章一開始對多型所下的定義：
「當某變數的實際型態和形式型態不一致時，呼叫此變數的 method，一定會呼叫到正確的版本，也就是實際型態的版本」。現在，你是不是比較能體會了。
如果我們嘗
試著呼叫 a 的 method2() 時，結果會呼叫到 ClassA 的 method2()，這是因為 ClassB 沒有定義 method2()，其 method2() 乃是繼承 ClassA 而來的。
如果我們嘗試著呼叫 a 的 method3() 時，則無法通過編譯。 這是因為 Java 是
強制型態檢查的語言（strongly-typed language），這意味著
編譯時會檢查形式型態是否有提供該 method。a 的
形式型態是 ClassA，不提供 method3()，雖然 a 的實際型態有提供 method3()，但編譯只管形式型態， 可不管實際型態，所以
形式型態也稱為編譯期型態（compile-time type），
實際型態也稱為執行期型態（runtime type）。
或許你會覺得「ClassA a = new ClassB();」的寫法很怪，為什麼要把 ClassB 的物件宣告成 ClassA 型態？的確，
通常我們不會這麼做，但形式型態和實際型態互異的情況卻往往是在不知不覺中發生，請看下面的例子：
class ClassA {
void method1() {
System.out.println("method1() in ClassA");
}
void method2() {
System.out.println("method2() in ClassA");
}
}
class ClassB extends ClassA {
void method1() {
System.out.println("method1() in ClassB");
}
void method3() {
System.out.println("method3() in ClassB");
}
}
class ClassD {
static void method4(ClassA a) {
// a 的形式型態是 ClassA，實際型態則不一定是 ClassA
a.method1(); //呼叫實際型態的 method1();
}
}
public classE {
public static void main(String[] args) {
ClassB b = new ClassB();
ClassD.method4(b);
// ClassD.method4() 需要一個 ClassA的參數，
// 因為 ClassB 繼承自 ClassA，
// 所以 ClassB 相容於 ClassA，
// 因此我們可以傳入 ClassB 的對象當參數
}
}因為我們傳進 ClassD.method4() 的參數其實際型態是 ClassB，但是在 method4() 的定義中將它宣告為 ClassA，造成了形式型態和實際型態不一致。這類似於「ClassA a = new ClassB();」的寫法，只不過一切都是在暗中進行，從程式上來看並不明顯。大部分的多型，都是導因於此。
從上面的例子來加以歸納，我們可以知道多型的發生必須是：
- 有直接或間接繼承關係的兩個類別，子類別的 method 將父類別的 method 予以override。
- 實際型態為子類別的物件，被當成父類別來使用，呼叫其 overrided method。
多型帶來什麼好處？
多型是建立在繼承的基礎之上的，沒有繼承，就不會有多型。
繼承的目的有兩種：
- 繼承程式碼：達到程式碼再用性（reuse）
- 繼承介面（interface）。達到介面再用性（reuse），為多型預作準備
更明白地說：
多型是仰賴介面的繼承。至於程式碼的繼承，完全無涉於多型。
讓我打個比喻：電腦主機板（Main Board）上面能夠插上 Intel 的 CPU，也能插上 AMD 的 CPU，一切運作順利，
那是因為 Intel 的 CPU 和 AMD 的 CPU 都遵守該主機板要求的介面（interface）。 這麼一來，任何廠商只要能符合此介面，就能和該主機板搭配使用，主機板不需要做出任何修改。
同樣地，
ClassD 的 method4() 需要 ClassA 的介面，不管是 ClassA 的 instance 和 ClassB 的 instance 都能符合這樣的要求（ClassB 繼承了 ClassA 的介面）， 所以都能當作 method4() 的參數，和 ClassD.method4() 合作無間。任何對象只要能符合 ClassA 的介面，就能和 ClassD 合作無間，ClassD 的程式碼不需要進行任何修改。 多型的機制，讓程式具備了動態的擴充性。
Reflection 也可以讓程式具備動態的擴充性，甚至比多型更動態，所以有些場合可以使用 reflection 來取代多型，但 reflection 通常效率較差，而且有的語言不提供 Reflection 機制。 Java 早在 1.1 以後就開始支援 Reflection API 了 ，而 Java1.4 版的 Reflection API 速度也大幅地提升了。如果你對於 Java Reflection API 感興趣的話，可以參考 java.lang.reflect.*。
多型的機制只用在 method 上，不用在 field 上
簡單來說，只要符合下兩點，就可能會有多型：
- 有直接或間接繼承關係的兩個類別，子類別的 method 將父類別的 method 予以 override。
- 實際型態為子類別的對象，被當成父類別來使用，呼叫其 overrided method。
請注意：上述兩點指的是 method，而非 field。對於 field 來說，根本沒有多型這一回事。請看下面的例子：
class ClassA {
String field1 = 'A1';
String field2 = 'A2';
}
class ClassB extends ClassA {
String field1 = 'B1';
String field3 = 'B3';
}
public class ClassC {
public static void main(String[] args) {
ClassA a = new ClassB();
System.out.println(a.field1()); // "A1"
System.out.println(a.field2()); // "A2"
System.out.println(a.field3()); // compile-time error
}
}，完全和實際型態無關。
雖然 a 的實際型態是 ClassB，但是形式型態是 ClassA，所以 a.field1 得到的結果是”A1”，a.field2 得到的結果是”A2”。
如果子類別提供了和父類別一樣名稱與參數的 method， 我們說子類別的 method 把父類別的同名 method 給 override 了。如果子類 別提供了和父類別一樣名稱的 field，我們說子類別的 field 把父類別的同名 field 給 shadow 了。
針對 method 和 field 的作法居然如此大的不同，這絕對不是 Java 語言的設計者故意想折磨你。事實上，這樣的設計有其巧妙之處。
在 Java 的思維中：介面是對象之間溝通的管道，而介面只包含了類別的名稱和 method 的集合。至於
field，則是不屬於介面的一部份。
既然如此，而多型又是完全是 依靠介面，所以當然多型會把 field 排除在外。
多型的機制只用在 instance method 上，不用在 class method 上
被 static 修飾的 field/method 是屬於 class field/method。繼承的時候，依然可以繼承這些 static field/method。封裝和繼承的效果可以同時用在 class 或 instance 上。換句話說：封裝不只封裝 instance field/method，也可以封裝 class field/method；繼承不只繼承父類的 instance field/method，也繼承父類別的 class field/method。
但是，切記，
多型只能對 instance 產生作用，不能對 class 產生作用，這可以從我對多型的定義看出端倪，定義如下：
當某變數的實際型態和形式型態不一致時，呼叫（invoke）此變數的 method，一定會呼叫到正確的版本，也就是實際型態的版本。
class 是形式型態，沒有實際型態，根本就和多型無關。
只有 instance 才可能會造成形式型態和實際型態不一致。
請看下面的例子：
class ClassA {
static void method1() {
System.out.println("method1() in ClassA");
}
static void method2() {
System.out.println("method2() in ClassA");
}
}
class ClassB extends ClassA {
static void method1() {
System.out.println("method1() in ClassB");
}
static void method3() {
System.out.println("method3() in ClassB");
}
}
public class ClassC {
public static void main(String[] args) {
ClassA a = new ClassB();
a.method1(); // method1() in ClassA
a.method2(); // method2() in ClassA
a.method3(); // compile-time error
}
}因為這裡的 method1()、method2()、method3() 都是 static，所以和多型無關，
編譯器直接使用靜態連結（static link），而不會留到執行期才動態地決定真正該呼叫的method 為何。因為編譯器在編譯期就做必須決定 method， 所以編譯器完全依賴形式型態，這麼一來「a.method1()」等於是「ClassA.method1()」， 「a.method2()」等於是「ClassA.method2()」。
多型的英文是 polymorphism，poly 是「多」的意思，morph 是「型」的意思，這個「型」可做「型態」解。
也就是說，只有當一件事物有多種型態時，才會有的一種機制。
請尊重文章版權
本文作者：蔡學鏞
張貼日期：09/25/2002
![clip_image002[6]](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjX8YRJYifsyKqCcg6Z2ouY7Ku5hyMQRBRDkdRGMxR-2WD_V4O272-xH8TbsRylsFaC-y9uxkFPMtVwfD8QSz1nCk3PcfYqE4lYrmJ9kxM-SaboH2m8qNxRNKMfvaEs-v5nkxvgSvHwLEo5/s1600-h/clip_image002%5B6%5D%5B2%5D.jpg "clip_image002[6]")
