首頁
中文書目錄
原文書目錄
 站內快速搜尋
資源中心
Book Series
Special Interest













■好消息,歐萊禮書籍已重新鋪貨至各大書局及網路書店,歡迎讀者選購       ■歡迎各院校採用歐萊禮書籍,學校團購請洽校園服務團隊

[技術短文]

OO


Java 是物件導向的(object-oriented)語言。物件導向近年來成為顯學,全新的程式語言幾乎都具備物件導向的特色,而舊的程式語言也紛紛在新版本中開始支援物件導向的特色。

所謂「物件導向的特色」,指的是物件導向的三個機制,三者缺一不可,此三個機制分別為封裝(encapsulation)、繼承(inheritance)、多型(polymorphism)。我也喜歡把這三個機制稱為三個階段,以突顯出它們之間的次序性:沒有封裝就不可能會有繼承,沒有繼承就不可能會有多型。為了稱呼上的方便,我們常常將物件導向簡稱為 OO。

有一些程式語言常被誤認為是 OO 的語言,但其實不然。例如:Visual Basic 6 以及更早的版本只支援封裝,不支援繼承和多型,所以不可以被視為 OO 的語言。這種只支援封裝 的語言,只能被稱為 object-based 程式語言。但是 Visual Basic 7(也就是 Visual Basic.NET)開始支援繼承和多型,所以可以被視為 OO 的語言,因此威力大增,語言的複雜度也會大增,因為繼承和多型會帶來許多複雜的特質。

封裝

關於封裝,你可以扮演兩種角色:
  • 封裝者:封裝出一個類別(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,就是一個類別)。畫面如下所示:



我很喜歡把程式設計比喻成設計一個主機板。主機板的設計者不用一切從頭來,因為他們有許多 IC chip(晶片)可以使用(其中有一個 chip 為 CPU)。從市面上的各種 chip 中(SIS、Intel、VIA…), 挑選出各種適合的 chip,再把這些 chip 全都放到主機板上適當的位置固定好,再把這些 chip 的接腳之間互相 連接起來就可以了。這麼一來,設計主機板的工作包含:
  1. 挑選 chip
  2. 應用這些 chip 來進行電路佈局(circuit layout)
寫程式很類似設計主機板,差異在於主機板是硬件,程式是軟件。寫 Java 程式不用一切從頭來,因為我們有許多類別可以使用。從 Java Core API 的類別中, 挑選出各種你需要的類別,把這些類別用在你的程式中,程式中利用 Java 的關鍵字(keyword) 和算符(operator)將這些類別銜接起來就可以了。這麼一來,寫程式的工作包含:
  1. 挑選適當的類別
  2. 應用這些類別來完成程式
繼承

既有的 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{
    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.lang.Object

在 Java 中,每個類別都會有父類別。如果你沒有用 extends 關鍵字來指定父類別,那麼它的父類別就是 java.lang.Object, 例如:code-6 的程式其實等同於下面的程式:

// code-7
class MyClass extends java.lang.Object {
    final int myMethod() {
        // ...
    }
}

java.lang.Object 是一個很特殊的類別,因為:
  • 它是唯一沒有父類別的類別
  • Java 所有的類別都直接或間接地繼承了 java.lang.Object
請牢記下面三點:
  1. 每個類別(java.lang.Object 除外)一定有一個父類別
  2. 一個父類別可以有許多子類別
  3. 所有的類別都源自於 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();但在 ode-4 中, ClassB 無法決定哪些 method/field 要繼承或不繼承。
特別注意:繼承一定需要「擴充」或「修改」,如果不擴充也不修改, 這樣的繼承就毫無意義可言。所謂的擴充,指的是:子類別新定義父類別沒有的 method,以擴充功能;所謂的修改,指的是子類別提供 method 推翻父類別的同名 method。

多型

關於多型(Polymorphism),一言以蔽之:「當某變數的實際型態(actual type)和形式型態(formal type)不一致時,呼叫此變數的 method,一定會呼叫到「正確」的版本, 也就是實際型態的版本。

從這句話,我們可以思索下面的問題:
  1. 為什麼實際型態和形式型態會不一致?
  2. 多型帶來時麼好處?
如果你能夠瞭解這兩點,你就能徹底瞭解多型。

學會多型之後,你不可以對多型有「錯誤的期待」。千萬要小心下面這兩點:
  1. 多型的機制只用在 method 上,不用在 field 上。
  2. 多型的機制只用在 instance method上,不用在 class method 上。
在本文章中,我也會對上述兩點提出明確的解釋。

為什麼實際型態和形式型態會不一致?

請看下面的例子:

int a = 3;
long b = a;

因為 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() 會 執行到哪一個版本?實際型態的版本或形式型態的版本?正確答案是實際型態的版本。這就是多型!

讓我們再看一次文章一開始對多型所下的定義:「當某變數的實際型態和形式型態不一致時,呼叫此變數的 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 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();」的寫法,只不過一切都是在暗中進行,從程式上來看並不明顯。大部分的多型,都是導因於此。

從上面的例子來加以歸納,我們可以知道多型的發生必須是:
  1. 有直接或間接繼承關係的兩個類別,子類別的 method 將父類別的 method 予以override。
  2. 實際型態為子類別的物件,被當成父類別來使用,呼叫其 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 上

簡單來說,只要符合下兩點,就可能會有多型:
  1. 有直接或間接繼承關係的兩個類別,子類別的 method 將父類別的 method 予以 override。
  2. 實際型態為子類別的對象,被當成父類別來使用,呼叫其 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
  }
}

對於 field 來說,形式型態決定了一切,完全和實際型態無關。 雖然 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

| 首頁 | 聯絡我們 |
© 2009, O'Reilly Media, Inc. Taiwan Branch