第1章

Transcription

1 第 10 章 類別的進階 - 繼承 抽象類別 介面與類別庫 1

2 本章提要 10.1 前言 10.2 繼承 10.3 改寫 10.4 Object 類別是類別之源 10.5 抽象類別 10.6 介面 10.7 內部類別 10.8 類別庫 10.9 綜合練習 後記 2

3 10.1 前言 本章將進ㄧ步來探討類別的進階應用, 包括以下主題 : 繼承 (Inheritance) 改寫 (Overriding) 抽象類別 (Abstract Class) 介面 (Interface) 內部類別 (Inner Class) 類別庫 (Package) 3

4 10.2 繼承 物件導向技術透過 類別的繼承 來達到軟體再用的目的父類別 (Super Classes) 基底類別 (Base Classes) 子類別 (Sub Classes) 衍生類別 (Derived Classes) 子類別可以繼承父類別的資料成員和方法, 並且可以加入自己所須要的資料成員和方法子類別可以建立自己的成員, 也可以存取到父類別裡的非私有 (non-private) 成員, 甚至也可以建立一個新方法來取代從父類別繼承而來的舊方法, 這種現象我們稱之為改寫 (Overriding) 4

5 10.2 繼承 圖 10.1: 類別的繼承 (a) 單一繼承 (b) 多重繼承 5

6 10.2 繼承 採用繼承技巧來撰寫程式 開發資訊系統有以下優點 : 程式碼較為簡潔 縮短開發時程 程式容易維護 6

7 定義子類別 7

8 定義子類別 8

9 定義子類別 9

10 類別繼承範例 範例程式 1 先呼叫父類別的建構元, 然後才呼叫子類別的建構元 2 // 程式名稱 :ch10_inheritance_1.java 6 class Base // 父類別 7 { 8 Base() // 建構元 9 { 10 System.out.println(" 執行父類別建構元 "); 11 } 12 } 14 class Derived extends Base // 子類別 15 { 16 Derived() // 建構元 17 { 18 System.out.println(" 執行子類別建構元 "); 19 } 20 } 10

11 類別繼承範例 22 public class ch10_inheritance_1 // 主程式 23 { 24 public static void main(string args[]) 25 { 26 Base b = new Base(); 27 System.out.println(" "); 28 Derived d = new Derived(); 29 } 30 } 執行結果 執行父類別建構元 執行父類別建構元執行子類別建構元 11

12 類別繼承範例 範例程式 2 方法的繼承, 呼叫父類別的方法, 呼叫子類別的方法 2 // 程式名稱 :ch10_inheritance_2.java 6 class Base // 父類別 7 { 8 Base() // 建構元 9 { 10 // System.out.println(" 執行父類別建構元 "); 11 } void mb() 14 { 15 System.out.println(" 執行父類別的 mb() 方法 "); 16 } 12

13 類別繼承範例 18 public void public_mb() 19 { 20 System.out.println(" 執行父類別的 public_mb() 方法 "); 21 } protected void protected_mb() 24 { 25 System.out.println(" 執行父類別的 protected_mb() 方法 "); 26 } private void private_mb() 29 { 30 System.out.println(" 執行父類別的 private_mb() 方法 "); 31 } 32 } 13

14 類別繼承範例 34 class Derived extends Base // 子類別 35 { 36 Derived() // 建構元 37 { 38 // System.out.println(" 執行子類別建構元 "); 39 } public void public_md() 42 { 43 System.out.println(" 執行子類別的 public_md() 方法 "); 44 this.mb(); 45 this.public_mb(); 46 this.protected_mb(); 47 // this.private_mb(); // 不可繼承 Base 類別的 private 方法 48 } 49 } 14

15 類別繼承範例 51 public class ch10_inheritance_2 // 主程式 52 { 執行結果 53 public static void main(string args[]) 執行父類別的 mb() 方法 54 { 執行父類別的 public_mb() 方法 55 Base b = new Base(); 執行父類別的 protected_mb() 方法 Derived d = new Derived(); 執行子類別的 public_md() 方法 57 d.mb(); 執行父類別的 mb() 方法 58 d.public_mb(); 執行父類別的 public_mb() 方法執行父類別的 protected_mb() 方法 59 d.protected_mb(); 60 // d.private_mb(); // 不可繼承 Base 類別的 private 方法 61 System.out.println(" "); 62 d.public_md(); 63 } 64 } 15

16 類別繼承範例 圖 10.3:Derived 類別繼承了 Base 類別的資料成員和方法 16

17 類別繼承範例 範例程式 3 資料成員的繼承, 呼叫父類別的方法, 呼叫子類別的方法 2 // 程式名稱 :ch10_inheritance_3.java 6 class Base // 父類別 7 { 8 int b1; 9 public int b2; 10 private int b3; 11 protected int b4; Base() // 建構元 14 { 15 // System.out.println(" 執行父類別建構元 "); 16 b1 = b2 = b3 = b4 = 1; 17 } 17

18 類別繼承範例 19 public void show() 20 { 21 System.out.printf("b1=%d, b2=%d, b3=%d, b4=%d\n", b1, b2, b3, b4); 22 } public void setb3(int i) 25 { 26 b3 = i; 27 } 28 } 18

19 類別繼承範例 30 class Derived extends Base // 子類別 31 { 32 int d1; Derived() // 建構元 35 { 36 // System.out.println(" 執行子類別建構元 "); 37 d1 = b1 * 100; 38 } public void print() 41 { 42 this.show(); 43 System.out.println("d1=" + d1); 44 } 19

20 類別繼承範例 46 public void set(int i) 47 { 48 b1 = i; 49 b2 = i; 50 this.setb3(i); // 不可寫成 b3 = i; 51 b4 = i; 52 d1 = i * 100; 53 } 54 } 20

21 類別繼承範例 56 public class ch10_inheritance_3 // 主程式 57 { 58 public static void main(string args[]) 59 { 60 Derived d = new Derived(); 61 d.show(); // 也可以用 d.show() 直接呼叫 Base 類別的 show() 方法 62 System.out.println(" "); 63 d.print(); 執行結果 64 d.set(5); 65 System.out.println(" "); b1=1, b2=1, b3=1, b4= d.print(); b1=1, b2=1, b3=1, b4=1 67 } d1= } b1=5, b2=5, b3=5, b4=5 d1=500 21

22 類別繼承範例 圖 10.3:Derived 類別繼承了 Base 類別的資料成員和方法 22

23 使用 super() 來呼叫父類別的建構元 用子類別來產生物件時, 會先呼叫父類別的建構元, 然後才呼叫子類別的建構元 當父類別裡沒有建構元時, 表示將採用預設建構元 ( 即沒有參數的建構元 ) 當父類別裡有數個建構元時, 若子類別沒有特別指定, 則內定是呼叫父類別的預設建構元 若父類別裡有數個建構元, 那麼在子類別中可以用 super() 來指定所要的建構元 super() 敘述必須放在建構元程式區塊的第一行 23

24 使用 super() 來呼叫父類別的建構元 範例程式 4 使用 super() 呼叫父類別的建構元 2 // 程式名稱 :ch10_super_1.java 6 class Base // 父類別 7 { 8 int b; 9 10 Base() // 這裡必須要有一個沒有參數的建構元, 以供 Derived() 呼叫 11 { 12 System.out.println(" 執行父類別建構元 Base()"); 13 b = 1; 14 } 15 24

25 使用 super() 來呼叫父類別的建構元 16 Base(int i) // 建構元 17 { 18 System.out.println(" 執行父類別建構元 Base(int i)"); 19 b = i; 20 } 21 } class Derived extends Base // 子類別 24 { 25 int d; Derived() // 建構元 28 { 29 System.out.println(" 執行子類別建構元 "); 30 d = 2; 31 } 25

26 使用 super() 來呼叫父類別的建構元 33 Derived(int i) // 建構元 34 { 35 super(i); // super() 敘述必須放在建構元程式碼的第一行 36 d = i; 37 System.out.println(" 執行子類別建構元 "); 38 } 執行結果 39 } 執行父類別建構元 Base() 41 public class ch10_super_1 // 主程式執行子類別建構元 42 { d1.b=1, d1.d=2 43 public static void main(string args[]) 執行父類別建構元 Base(int i) 44 { 執行子類別建構元 d2.b=3, d2.d=3 45 Derived d1 = new Derived(); 46 System.out.println("d1.b=" + d1.b + ", d1.d=" + d1.d); 47 Derived d2 = new Derived(3); 48 System.out.println("d2.b=" + d2.b + ", d2.d=" + d2.d); 49 } 50 } 26

27 類別階層 圖 10.4: 類別階層圖 27

28 類別階層 範例程式 5 類別階層, 必須先呼叫父類別的建構元 2 // 程式名稱 :ch10_classhierarchy.java 6 class Vehicle 7 { 8 Vehicle() 9 { 10 System.out.println(" 執行 Vehicle 建構元 "); 11 } 12 } 14 class Car extends Vehicle 15 { 16 Car() 17 { 18 System.out.println(" 執行 Car 建構元 "); 19 } 20 } 28

29 類別階層 22 class Taxi extends Car 23 { 24 Taxi() 25 { 26 System.out.println(" 執行 Taxi 建構元 "); 27 } 28 } class Bus extends Car 31 { 32 Bus() 33 { 34 System.out.println(" 執行 Bus 建構元 "); 35 } 36 } 29

30 類別階層 38 public class ch10_classhierarchy 39 { 40 public static void main(string args[]) 41 { 42 Car car = new Car(); 43 System.out.println(" "); 44 Taxi taxi = new Taxi(); 45 System.out.println(" "); 46 Bus bus = new Bus(); 47 } 48 } 執行結果 執行 Vehicle 建構元執行 Car 建構元 執行 Vehicle 建構元執行 Car 建構元執行 Taxi 建構元 執行 Vehicle 建構元執行 Car 建構元執行 Bus 建構元 30

31 繼承與包含於 繼承是一個 屬於 (Is a) 的關係, 例如圖 10.4 中, 汽車 是 運輸工具 的子類別, 它隱含兩個意義 : 1. 汽車可以繼承運輸工具的資料成員和成員方法 2. 汽車屬於一種運輸工具除了繼承之外, 類別與類別間的關係也可能是一種 包含於 (Has a) 的關係下面這個例子中,A 類別的 a 物件包含於 B 類別之中, 換言之,a 物件是 B 類別的一部份 31

32 繼承與包含於 範例程式 6 類別間的包含於 (Has a) 的關係 2 // 程式名稱 :ch10_has_a.java 6 class A 7 { 8 A() 9 { 10 System.out.println(" 執行 A 別的建構元 "); 11 } 12 public void ma() 13 { 14 System.out.println(" 執行 A 類別的 ma() 方法 "); 15 } 16 } 32

33 繼承與包含於 18 class B 19 { 20 A a; // A 類別的 a 物件包含於 B 類別之中, 是 B 類別的一部份 B() 23 { 24 System.out.println(" 執行 B 別的建構元 "); 25 a = new A(); // 在 B 類別裡面產生一個 A 類別的物件 26 // mb(); 可以直接執行 mb() 方法 27 } public void mb() 30 { 31 System.out.println(" 執行 B 類別的 mb() 方法 "); 32 a.ma(); 33 // ma(); 不可以直接執行 mb() 方法 34 } 35 } 33

34 繼承與包含於 37 public class ch10_has_a 38 { 39 public static void main(string args[]) 40 { 41 B b = new B(); 42 b.mb(); 43 // a.ma(); // 錯誤的用法 44 } 執行結果 45 } 執行 B 別的建構元執行 A 別的建構元執行 B 類別的 mb() 方法執行 A 類別的 ma() 方法 34

35 extends 只能單一繼承 不可以寫成 : class Derived extends Base1,Base2 {... } 35

36 多型 多載與改寫 多型 (Polymorphism)( 或稱同名異式 ) 是物件導向的特性之一, 顧名思義, 它指的是採用同樣的方法名稱, 但在不同場合扮演不同的角色多型可以用下列幾種技術來實踐 : 多載 (9.6.6 節 ) 改寫 (10.3 節 ) 抽象類別與抽象方法的實作 (10.5 節 ) 介面的定義與實作 (10.6 節 ) 36

37 多型 多載與改寫 改寫與多載之比較 改寫 (Overriding) 發生在子類別 方法名稱相同 方法的參數個數 資料型別 傳回值都和父類別裡的方法相同 多載 (Overloading) 發生在同一個類別裡 方法名稱相同 方法的參數個數或資料型別有所差異 37

38 方法的改寫 範例程式 7 改寫與多載 2 // 程式名稱 :ch10_overriding.java 6 class Car 7 { 8 Car(){} 9 10 public void drive() // 預設 Car 為自排車 11 { 12 System.out.println(" 開自排車, 不須換擋 "); 13 } 14 } class Taxi extends Car 17 { 18 Taxi(){} 19 } 38

39 方法的改寫 21 class Bus extends Car 22 { 23 Bus(){} public void drive() // 改寫 Car 類別的 drive() 26 { 27 System.out.println(" 開手排 Bus, 必須換擋 "); 28 } public void drive(string s) // 多載 31 { 32 System.out.print("Bus 為 " + s + ","); 33 if(s == " 自排 ") 34 super.drive(); // 呼叫父類別的 drive() 35 else if(s == " 手排 ") 36 System.out.println(" 開手排 Bus, 必須換擋 "); 37 } 38 } 39

40 方法的改寫 40 public class ch10_overriding 41 { 42 public static void main(string args[]) 43 { 44 Taxi taxi = new Taxi(); 45 taxi.drive(); Bus bus = new Bus(); 48 bus.drive(); 49 bus.drive(" 自排 "); 50 bus.drive(" 手排 "); 執行結果 51 } 開自排車, 不須換擋 52 } 開手排 Bus, 必須換擋 Bus 為自排, 開自排車, 不須換擋 Bus 為手排, 開手排 Bus, 必須換擋 40

41 以父類別的物件變數呼叫子類別的方法 範例程式 8 用父類別的物件變數來呼叫子類別之方法 2 // 程式名稱 :ch10_overriding_1.java 6 class Vehicle 7 { 8 Vehicle(){} 9 10 public void start() 11 { 12 System.out.println(" 發動引擎 "); 13 } 14 } 41

42 以父類別的物件變數呼叫子類別的方法 16 class Car extends Vehicle 17 { 18 Car(){} public void drive() 21 { 22 System.out.println(" 開自排車, 不須換擋 "); 23 } 24 } 26 class Taxi extends Car 27 { 28 Taxi(){} public void drive() 31 { 32 System.out.println(" 開自排 Taxi, 不須換擋 "); 33 } 34 } 42

43 以父類別的物件變數呼叫子類別的方法 36 class Bus extends Car 37 { 38 Bus(){} public void drive() 41 { 42 System.out.println(" 開手排 Bus, 必須換擋 "); 43 } 44 } 43

44 以父類別的物件變數呼叫子類別的方法 46 public class ch10_overriding_1 47 { 48 public static void main(string args[]) 49 { 50 Taxi taxi = new Taxi(); 執行結果 51 taxi.start(); 發動引擎 52 taxi.drive(); 開自排 Taxi, 不須換擋 53 發動引擎 54 Car car = new Bus(); 開手排 Bus, 必須換擋 55 car.start(); 56 car.drive(); // 可以用父類別的物件變數來呼叫子類別之方法 57 } 58 } 44

45 動態方法分派 範例程式 9 動態方法分派 2 // 程式名稱 :ch10_dynamicmd.java 6 class Car 7 { 8 Car(){} 9 10 public void drive() 11 { 12 System.out.println(" 開自排車, 不須換擋 "); 13 } 14 } 15 45

46 動態方法分派 16 class Taxi extends Car 17 { 18 Taxi(){} public void drive() 21 { 22 System.out.println(" 開自排 Taxi, 不須換擋 "); 23 } 24 } 26 class Bus extends Car 27 { 28 Bus(){} public void drive() 31 { 32 System.out.println(" 開手排 Bus, 必須換擋 "); 33 } 46

47 動態方法分派 36 public class ch10_dynamicmd 37 { 38 public static void main(string args[]) 39 { 40 Car x; 41 Car car = new Car(); 42 Taxi taxi = new Taxi(); 43 Bus bus = new Bus(); 45 x = car; 46 x.drive(); 執行結果 48 x = taxi; 開自排車, 不須換擋 49 x.drive(); 開自排 Taxi, 不須換擋 51 x = bus; 開手排 Bus, 必須換擋 52 x.drive(); 53 } 54 } 47

48 使用 final 來禁止改寫 範例程式 10 使用 final 來禁止改寫 2 // 程式名稱 :ch10_overriding_f1.java 6 class Car 7 { 8 Car(){} 9 10 final public void drive() // 使用 final 來禁止改寫 11 { 12 System.out.println(" 開自排車, 不須換擋 "); 13 } 14 } 15 48

49 使用 final 來禁止改寫 16 class Bus extends Car 17 { 18 Bus(){} public void drive() // 不可改寫 Car 類別的 drive() 21 { 22 System.out.println(" 開手排車, 必須換擋 "); 23 } 24 } 25 49

50 使用 final 來禁止改寫 26 public class ch10_overriding_f1 27 { 28 public static void main(string args[]) 29 { 30 Bus bus = new Bus(); 31 bus.drive(); 32 } 33 } 50

51 使用 final 來禁止繼承 範例程式 11 使用 final 來停止繼承 2 // 程式名稱 :ch10_overriding_f2.java 6 final class Car 7 { 8 Car(){} 9 10 public void drive() 11 { 12 System.out.println(" 開自排車, 不須換擋 "); 13 } 14 } 51

52 使用 final 來禁止繼承 16 class Bus extends Car // 不可繼承 Car 類別 17 { 18 Bus(){} public void drive() 21 { 22 System.out.println(" 開手排車, 必須換擋 "); 23 } 24 } 26 public class ch10_overriding_f2 27 { 28 public static void main(string args[]) 29 { 30 Bus bus = new Bus(); 31 bus.drive(); 32 } 33 } 52

53 使用 final 來禁止繼承 53

54 10.4 Object 類別是類別之源 圖 10.5: 所有類別都繼承自 Object 類別 54

55 10.4 Object 類別是類別之源 55

56 10.4 Object 類別是類別之源 範例程式 12 Object 類別,getClass() 方法, getsuperclass() 方法 2 // 程式名稱 :ch10_object.java 6 class Car 7 { 8 Car(){} 9 } class Taxi extends Car 12 { 13 Taxi(){} 14 } 執行結果 car1 所指的物件是屬於 class Car car2 所指的物件是屬於 class Taxi taxi 所指的物件是屬於 class Taxi Taxi 類別的父類別是 class Car Taxi 類別的父類別是 class Car 56

57 10.4 Object 類別是類別之源 16 public class ch10_object 17 { 18 public static void main(string args[]) 19 { 20 Car car1 = new Car(); 21 System.out.println("car1 所指的物件是屬於 " + car1.getclass()); 23 Car car2 = new Taxi(); 24 System.out.println("car2 所指的物件是屬於 " + car2.getclass()); 26 Taxi taxi = new Taxi(); 27 Class classname = taxi.getclass(); 28 System.out.println("taxi 所指的物件是屬於 " + classname); 30 Class superclassname = taxi.getclass().getsuperclass(); 31 System.out.println("Taxi 類別的父類別是 " + superclassname); 32 System.out.println("Taxi 類別的父類別是 " + 33 classname.getsuperclass()); 34 } 35 } 57

58 抽象類別與抽象方法 抽象類別是一個很特殊的父類別, 在抽象類別裡可以定義抽象方法, 然後要求繼承它的子類別一定要重新撰寫程式碼來取代父類別裡的抽象方法抽象類別用來定義一個範本, 然後強迫子類別依照這個範本來實作程式碼這裡的範本指的是抽象方法的定義, 包括傳回值資料型別 方法名稱 參數列等, 而並不包括程式碼的實作 58

59 抽象類別與抽象方法 圖 10.7: 抽象類別與抽象方法 59

60 定義抽象類別 不能直接用抽象類別來建立物件, 而是要透過抽象類別的子類別來建立物件抽象類別裡的抽象方法不可以宣告為 private 60

61 抽象類別的實作 範例程式 13 抽象類別 2 // 程式名稱 :ch10_abstract_1.java 6 abstract class Car 7 { 8 int cc; 9 10 int getcc() 11 { 12 return cc; 13 } abstract void drive(); // 只有定義, 沒有實作 16 } 61

62 抽象類別的實作 18 class Taxi extends Car 19 { 20 Taxi(int ccno) 21 { 22 cc = ccno; 23 } 25 void drive() // 實作 26 { 27 System.out.println("Taxi 為 " + getcc() + "cc 的自排車, 不須換擋 "); 28 } 29 } 31 class Bus extends Car 32 { 33 void drive() // 實作 34 { 35 System.out.println("Bus 為手排車, 必須換擋 "); 36 } 37 } 62

63 抽象類別的實作 39 public class ch10_abstract_1 40 { 41 public static void main(string args[]) 42 { 43 // Car car = new Car(); // Car 是抽象類別, 不可用來產生物件 44 // car.drive(); 45 Taxi taxi = new Taxi(2000); 46 taxi.drive(); 47 Bus bus = new Bus(); 48 bus.drive(); 49 } 50 } 執行結果 Taxi 為 2000cc 的自排車, 不須換擋 Bus 為手排車, 必須換擋 63

64 抽象類別的實作 範例程式 14 抽象類別, 子類別也是抽象類別 2 // 程式名稱 :ch10_abstract_2.java 6 abstract class Car 7 { 8 abstract void drive(string obj); // 只有定義, 沒有實作 9 } abstract class Bus extends Car 12 { 13 } 執行結果 newbus 為單軌自動電車, 不須駕駛 car 為單軌自動電車, 不須駕駛 64

65 抽象類別的實作 15 class NewBus extends Bus 16 { 17 void drive(string obj) // 實作 18 { 19 System.out.println(obj + " 為單軌自動電車, 不須駕駛 "); 20 } 23 public class ch10_abstract_2 21 } 24 { 25 public static void main(string args[]) 26 { 27 Car newbus = new NewBus(); 28 newbus.drive("newbus"); // 父類別的變數 (car) 可以指向孫類別 (NewBus) 的物件 31 Car car = new NewBus(); 32 car.drive("car"); 33 } 34 } 65

66 10.6 介面 (a) 使用 extends (b) 使用 interface/implements 圖 10.8: 多重繼承的兩種實作方式 66

67 介面的定義與實作 final 和 abstract 是預設的, 可以省略 67

68 介面的定義與實作 在子類別裡實作介面的抽象方法時, 該方法必須宣告為 public 68

69 介面的定義與實作 範例程式 15 介面的定義與實作 2 // 程式名稱 :ch10_interface_1.java 6 interface ICar 7 { 8 final String color = " 黃色 "; 9 abstract void passenger(); // 只有定義, 沒有實作 10 } 69

70 介面的定義與實作 12 class Taxi implements ICar 13 { 14 int cc; Taxi(int cc) 17 { 18 this.cc = cc; 19 } public void passenger() // 實作 22 { 23 System.out.println(" 計程車是 " + color + "," + cc + 24 "cc, 可以載 4 名乘客 "); 25 } 26 } 70

71 介面的定義與實作 28 class Bus implements ICar 29 { 30 public void passenger() // 實作 31 { 32 System.out.println(" 校車是 " + color + ", 可以載 50 名乘客 "); 33 } 34 } 36 public class ch10_interface_1 37 { 38 public static void main(string args[]) 39 { 40 Taxi taxi = new Taxi(2000); 執行結果 41 taxi.passenger(); 計程車是黃色,2000cc, 可以載 4 名乘客 42 Bus bus = new Bus(); 校車是黃色, 可以載 50 名乘客 43 bus.passenger(); 44 } 45 } 71

72 使用介面來處理多重繼承 圖 10.9: 多重繼承 72

73 使用介面來處理多重繼承 範例程式 16 多重繼承 2 // 程式名稱 :ch10_interface_2.java 6 interface IFather 7 { 8 final String lastname = " 張 "; // 姓氏 9 abstract void character(string c); // 性格 10 } interface IMother 13 { 14 final String lastname = " 李 "; // 姓氏 15 abstract void hobby(string h); // 嗜好 16 } 73

74 使用介面來處理多重繼承 18 class Child implements IFather,IMother 19 { 20 String lastname; // 姓氏 21 String id; // 身分證字號 22 String character; // 性格 23 String hobby; // 嗜好 Child(String name, String id) 26 { 27 this.lastname = IFather.lastname + name; 28 this.id = id; 29 } 74

75 使用介面來處理多重繼承 31 public void show() 32 { 33 System.out.println(lastname + " 的母親姓 " + IMother.lastname); 34 System.out.print(lastname + " 的身分證字號為 " + id + ", 擁有 "); 35 System.out.println(character + " 的性格和 "+ hobby + " 的嗜好 "); 36 } public void character(string chr) // 實作性格 39 { 40 character = chr; 41 } public void hobby(string h) // 實作嗜好 44 { 45 hobby = h; 46 } 47 } 75

76 使用介面來處理多重繼承 49 public class ch10_interface_2 50 { 51 public static void main(string args[]) 52 { 53 Child child = new Child(" 三 ","A "); 54 child.character(" 樂觀開朗 "); 55 child.hobby(" 打籃球 "); 56 child.show(); 57 } 58 } 執行結果 張三的母親姓李張三的身分證字號為 A , 擁有樂觀開朗的性格和打籃球的嗜好 76

77 介面的繼承 77

78 介面的繼承 範例程式 17 介面的繼承 2 // 程式名稱 :ch10_interface_3.java 6 interface IFamily 7 { 8 abstract void show(); // 列印 9 } interface IFather extends IFamily 12 { 13 final String lastname = " 張 "; // 姓氏 14 abstract void character(string c); // 性格 15 } 78

79 介面的繼承 17 class Child implements IFather 18 { 19 String lastname; // 姓氏 20 String id; // 身分證字號 21 String character; // 性格 Child(String name, String id) 24 { 25 this.lastname = IFather.lastname + name; 26 this.id = id; 27 } public void show() // 實作列印 30 { 31 System.out.print(lastname + " 的身分證字號為 " + id + ", 擁有 "); 32 System.out.println(character + " 的性格 "); 33 } 79

80 介面的繼承 35 public void character(string chr) // 實作性格 36 { 37 character = chr; 38 } 39 } public class ch10_interface_3 42 { 43 public static void main(string args[]) 44 { 45 Child child = new Child(" 三 ","A "); 46 child.character(" 樂觀開朗 "); 47 child.show(); 48 } 執行結果 49 } 張三的身分證字號為 A , 擁有樂觀開朗的性格 80

81 10.7 內部類別 如果在 A 類別程式區塊裡面又定義了一個 B 類別, 那麼我們稱 B 類別為內部類別 (Inner Class), 而稱 A 類別為外部類別 (Outer Class) 我們可以將內部類別視為外部類別的成員, 可以再 A 類別裡產生一個 B 類別的物件 81

82 內部類別之定義 82

83 內部類別之定義 範例程式 18 Square 類別 ( 正方形類別 ) 2 // 程式名稱 :ch10_square_1.java 6 class Square 7 { 8 int x; 10 Square(int x) 11 { 12 this.x = x; 13 } 15 public int getarea() 16 { 17 return x*x; 18 } 19 } 83

84 內部類別之定義 21 public class ch10_square_1 22 { 23 public static void main(string args[]) 24 { 25 int x = 5; 26 Square s = new Square(x); System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d\n", x, s.getarea()); 29 } 30 } 執行結果 邊長為 5 的正方形, 其面積為 25 這支程式有 ch10_square_1 和 Square 兩個類別, 只要將 Square 類別 ( 第 6-19 行 ) 搬移到第 22 行之後, 就成為內部類別的形式了 84

85 內部類別之定義 範例程式 20 透過外部類別的物件來呼叫內部類別裡的方法 2 // 程式名稱 :ch10_inner_2.java 6 public class ch10_inner_2 // 外部類別 7 { 8 ch10_inner_2(int x) // 外部類別的建構元 9 { 10 Square s = new Square(x); 11 s.getarea(); 12 } 13 85

86 內部類別之定義 14 class Square // 內部類別, 這種寫法內部類別可以不必宣告為 static 15 { 16 int x; 18 Square(int x) // 建構元 19 { 執行結果 20 this.x = x; 邊長為 5 的正方形, 其面積為 } 23 public void getarea() 24 { 25 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d\n", x, x*x); 26 } 27 } 29 public static void main(string args[]) // 主程式 30 { 31 int x = 5; 32 ch10_inner_2 inner_2 = new ch10_inner_2(x); 33 } 34 } 86

87 內部類別之定義 範例程式 21 將外部類別獨立於主程式之外 2 // 程式名稱 :ch10_inner_3.java 6 class Outer // 外部類別 7 { 8 Outer(int x) // 外部類別的建構元 9 { 10 Square s = new Square(x); 11 s.getarea(); 12 } 13 87

88 內部類別之定義 14 class Square // 內部類別, 這種寫法內部類別可以不必宣告為 static 15 { 16 int x; Square(int x) // 建構元 19 { 20 this.x = x; 21 } public void getarea() 24 { 25 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d\n", x, x*x); 26 } 27 } 28 } 88

89 內部類別之定義 30 public class ch10_inner_3 31 { 32 public static void main(string args[]) // 主程式 33 { 34 int x = 5; 35 Outer o = new Outer(x); 36 } 37 } 執行結果 邊長為 5 的正方形, 其面積為 25 89

90 巢狀類別之定義 類別內部又有一個類別成員, 就成了巢狀類別從外部類別呼叫內部類別方法的格式為 : 內部類別物件. 內部類別方法名稱 () 從外部類別存取內部類別的資料成員的格式為 : 內部類別物件. 內部類別資料成員名稱外部類別可以透過內部類別物件來存取內部類別的 private 成員 90

91 巢狀類別之定義 範例程式 21 將外部類別獨立於主程式之外 2 // 程式名稱 :ch10_inner_4.java 6 class Outer // 外部類別 7 { 8 Square s; // 內部類別變數 9 10 Outer(int x) // 外部類別建構元 11 { 12 s = new Square(x); 13 } public void show() // 外部類別方法 16 { 17 s.getarea(); 18 } 91

92 巢狀類別之定義 20 class Square // 內部類別, 這種寫法內部類別可以不必須宣告為 static 21 { 22 int x; Square(int x) // 內部類別建構元 25 { 26 this.x = x; 27 } private void getarea() // 內部類別方法 30 { 31 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d\n", x, x*x); 32 } 33 } 34 } 92

93 巢狀類別之定義 36 public class ch10_inner_4 37 { 38 public static void main(string args[]) // 主程式 39 { 40 int x = 5; 41 Outer o = new Outer(x); 42 o.show(); 43 // o.getarea(); 這行敘述是錯誤的用法, 必須改為備註 44 } 45 } 執行結果 邊長為 5 的正方形, 其面積為 25 93

94 巢狀類別之定義 範例程式 23 巢狀類別, 內部類別就沒有成員函式 2 // 程式名稱 :ch10_inner_5.java 6 class Outer // 外部類別 7 { 8 Square s; // 內部類別變數 9 10 Outer(int x) // 外部類別建構元 11 { 12 s = new Square(x); 13 } public void show() // 外部類別方法 16 { 17 getarea(); 18 } 94

95 巢狀類別之定義 20 public void getarea() // 外部類別方法 21 { 22 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d\n", s.x, s.x*s.x); 23 } class Square // 內部類別, 這種寫法內部類別可以不必須宣告為 static 26 { 27 int x; Square(int x) // 內部類別建構元 30 { 31 this.x = x; 32 } 33 } 34 } 95

96 巢狀類別之定義 36 public class ch10_inner_5 37 { 38 public static void main(string args[]) // 主程式 39 { 40 int x = 5; 41 Outer o = new Outer(x); 42 o.show(); 43 o.getarea(); 44 } 45 } 執行結果 邊長為 5 的正方形, 其面積為 25 邊長為 5 的正方形, 其面積為 25 96

97 匿名內部類別之定義 97

98 匿名內部類別之定義 範例程式 24 匿名內部類別 2 // 程式名稱 :ch10_anonymousinner_1.java 6 class Outer // 外部類別 7 { 8 Outer(int x) 9 { 10 ( // 匿名內部類別 11 new Square(x) // 建立匿名內部類別物件 12 { 13 public void getarea() 14 { 15 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d\n", x, x*x); 16 } 17 } 18 ).getarea(); // 呼叫匿名類別裡的方法 19 } 20 } 98

99 匿名內部類別之定義 22 class Square 23 { 24 int x; Square(int x) 27 { 28 this.x = x; 執行結果 29 } 30 } 邊長為 5 的正方形, 其面積為 public class ch10_anonymousinner_1 33 { 34 public static void main(string args[]) 35 { 36 int x = 5; 37 Outer s = new Outer(x); 38 } 39 } 99

100 匿名內部類別之定義 範例程式 25 匿名內部類別 2 // 程式名稱 :ch10_anonymousinner_2.java 6 class Outer // 外部類別 7 { 8 Outer(int x) 9 { 10 ( // 匿名內部類別 11 new Square(x) // 建立匿名內部類別物件 12 { 13 public void getarea() 14 { 15 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d", x, x*x); 16 } 17 } 18 ).getarea(); // 呼叫匿名類別裡的方法 19 } 100

101 匿名內部類別之定義 21 class Square 22 { 23 int x; Square(int x) 26 { 27 this.x = x; 28 } 29 } 執行結果 30 } 邊長為 5 的正方形, 其面積為 public class ch10_anonymousinner_2 33 { 34 public static void main(string args[]) 35 { 36 int x = 5; 37 Outer s = new Outer(x); 38 } 39 } 101

102 匿名內部類別之定義 範例程式 25 匿名內部類別 10 ( // 匿名內部類別 11 new Square(x) // 建立匿名內部類別物件 12 { 13 public void getarea() 14 { 15 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d", x, x*x); 16 } 17 } 18 ).getarea(); // 呼叫匿名類別裡的方法 19 } 10 (new Square(x){public void getarea(){ 11 System.out.printf(" 邊長為 %d 的正方形, 其面積為 %d", x, x*x);}} 12 ).getarea(); 102

103 類別庫的觀念 大型資訊系統的開發通常須要許多人同心協力共同合作來完成, 將整個系統分成許多子系統, 再將子系統分成許多功能項目, 然後針對功能項目分別進行程式的撰寫工作系統分析師 ( 或設計師 ) 也會事先規劃出須要哪些程式檔, 程式檔裡應有哪些類別, 並且規定好類別檔 (.class) 要存放到哪一個類別庫, 然後才交由程式設計師來撰寫程式程式設計師須依規定將程式編譯後產生的類別檔放置到指定的類別庫 (Package) 裡, 等所有的程式都完成後須進行整合, 以成為一個完整的資訊系統類別庫就像檔案夾 ( 或稱為目錄 ), 編譯產生的類別檔可以存放到指定的類別庫, 另外, 也可以從指定的類別庫找到所須的類別檔來重複使用類別庫也稱為套件 103

104 將類別檔存放到指定的類別庫 假設已經有一支程式 ch10_package_1.java 儲存檔案夾 ( 目錄 )C:\java\ch10\pack1 裡, 我們希望編譯該程式後所產生的類別檔也存放於 C:\java\ch10\pack1 檔案夾裡, 那麼只須在程式的開頭加上一行敘述 : package pack1; 用這行敘述來告訴編譯器, 將類別檔存放到現行目錄 (C:\java\ch10\) 下的 pack1 這個類別庫裡 104

105 將類別檔存放到指定的類別庫 範例程式 26 將類別檔存放到指定的類別庫 2 // 程式名稱 :ch10_package_1.java 6 package pack1; 7 class Car 8 { 9 Car(){} public void drive() // 預設 Car 為字排車 12 { 13 System.out.println(" 開自排車, 不須換擋 "); 14 } 15 } 105

106 將類別檔存放到指定的類別庫 17 public class ch10_package_1 18 { 19 public static void main(string args[]) 20 { 21 Car car = new Car(); 22 car.drive(); 23 } 24 } 106

107 將類別檔存放到指定的類別庫 107

108 將程式檔分割, 並將類別檔存放到指定的類別庫 檔案夾 C:\java\ch10\pack2 :ch10_package_21.java 檔案夾 C:\java\ch10\pack2 :ch10_package_22.java 108

109 將程式檔分割, 並將類別檔存放到指定的類別庫 範例程式 27-1 將程式檔分割, 並將類別檔存放到指定的類別庫 2 // 程式名稱 :ch10_package_21.java 6 package pack2; 7 public class ch10_package_21 8 { 9 public static void main(string args[]) 10 { 11 Car car = new Car(); 12 car.drive(); 13 } 14 } 109

110 將程式檔分割, 並將類別檔存放到指定的類別庫 範例程式 27-2 將程式檔分割, 並將類別檔存放到指定的類別庫 2 // 程式名稱 :ch10_package_22.java 6 package pack2; 7 class Car 8 { 9 Car(){} public void drive() // 預設 Car 為字排車 12 { 13 System.out.println(" 開自排車, 不須換擋 "); 14 } 15 } 110

111 將程式檔分割, 並將類別檔存放到指定的類別庫必須先編譯 ch10_package_22.java 然後才編譯 ch10_package_21.java 111

112 如何取用不同類別庫裡的類別檔 檔案夾 C:\java\ch10\pack3\pack31 : ch10_package_31.java 檔案夾 C:\java\ch10\pack3\pack32 :Car.java 112

113 如何取用不同類別庫裡的類別檔 範例程式 28-1 取用不同類別庫裡的類別檔 2 // 程式名稱 :ch10_package_31.java 6 package pack31; 7 public class ch10_package_31 8 { 9 public static void main(string args[]) 10 { 11 pack32.car car = new pack32.car(); 12 car.drive(); 13 } 14 } 113

114 如何取用不同類別庫裡的類別檔 範例程式 28-2 將類別檔存放到指定的類別庫 2 // 程式名稱 :Car.java 6 package pack32; 7 public class Car 8 { 9 public Car(){} public void drive() // 預設 Car 為字排車 12 { 13 System.out.println(" 開自排車, 不須換擋 "); 14 } 15 } 114

115 如何用 import 來取用不同類別庫裡的類別檔 檔案夾 C:\java\ch10\pack4\pack41 : ch10_package_41.java 檔案夾 C:\java\ch10\pack4\pack42 :Car.java import 類別庫名稱. 類別名稱 ; 115

116 如何用 import 來取用不同類別庫裡的類別檔 範例程式 29-1 用 import 來取用不同類別庫裡的類別檔 2 // 程式名稱 :ch10_package_41.java 6 package pack41; 7 import pack42.car; 8 public class ch10_package_41 9 { 10 public static void main(string args[]) 11 { 12 Car car = new Car(); 13 car.drive(); 14 } 15 } 116

117 如何用 import 來取用不同類別庫裡的類別檔 範例程式 29-2 將類別檔存放到指定的類別庫 2 // 程式名稱 :Car.java 6 package pack42; 7 public class Car 8 { 9 public Car(){} public void drive() // 預設 Car 為字排車 12 { 13 System.out.println(" 開自排車, 不須換擋 "); 14 } 15 } 117

118 如何用 import 來取用子類別庫裡的類別檔 Import 類別庫名稱. 子類別庫名稱. 類別名稱 ; 檔案夾 C:\java\ch10\pack5\ :ch10_package_5.java 檔案夾 C:\java\ch10\pack5\pack51 :Car.java 檔案夾 C:\java\ch10\pack5\pack52 :Bus.java 118

119 如何用 import 來取用子類別庫裡的類別檔 範例程式 30-1 用 import 來取用子類別庫裡的類別檔 2 // 程式名稱 :ch10_package_5.java 6 package pack5; 7 import pack5.pack51.car; 8 import pack5.pack52.bus; 9 public class ch10_package_5 10 { 11 public static void main(string args[]) 12 { 13 Car car = new Car(); 14 car.drive(); 16 Bus bus = new Bus(); 17 bus.drive(); 18 bus.drive(" 自排 "); 19 bus.drive(" 手排 "); 20 } 21 } 119

120 如何用 import 來取用子類別庫裡的類別檔 範例程式 30-2 將類別檔存放到指定的類別庫 2 // 程式名稱 :Car.java 6 package pack5.pack51; 7 public class Car 8 { 9 public Car(){} public void drive() // 預設 Car 為字排車 12 { 13 System.out.println(" 開自排車, 不須換擋 "); 14 } 15 } 120

121 如何用 import 來取用子類別庫裡的類別檔 範例程式 30-3 用 import 來取用子類別庫裡的類別檔 2 // 程式名稱 :Bus.java 6 package pack5.pack52; 7 import pack5.pack51.car; 8 public class Bus extends Car 9 { 10 public Bus(){} public void drive() // 改寫 Car 類別的 drive() 13 { 14 System.out.println(" 開手排 Bus, 必須換擋 "); 15 } 121

122 如何用 import 來取用子類別庫裡的類別檔 17 public void drive(string s) // 多載 18 { 19 System.out.print("Bus 為 " + s + ","); 20 if(s == " 自排 ") 21 super.drive(); // 呼叫父類別的 drive() 22 else if(s == " 手排 ") 23 System.out.println(" 開手排 Bus, 必須換擋 "); 24 } 25 } 122

123 排序 氣泡排序法 10.9 綜合練習 排序 - 介面的應用 氣泡排序法, 介面的應用 123

124 10.10 後記 物件導向技術透過 類別的繼承 來達到軟體再用的目的 子類別可以繼承父類別的資料成員和方法, 並且可以加入自己所須要的資料成員和方法 子類別可以建立自己的成員, 也可以存取到父類別裡的非私有 (non-private) 成員, 甚至也可以建立一個新方法來取代從父類別繼承而來的舊方法, 這種現象我們稱之為改寫在 Java 裡, 定義類別時用 extends 來處理單一繼承, 而 Interface 用來實作多重繼承 124

125 10.10 後記 父類別中, 宣告為 public protected 和沒有指定修飾子的成員是可以被子類別所繼承 子類別無法存取父類別的 private 成員, 除非是透過父類別提供的方法來存取 父類別中的建構子以及設定為終止繼承的成員, 也是子類別無法繼承的父類別 子類別各有各的建構元, 當用子類別來產生物件時, 會先執行父類別的建構元, 然後才執行子類別的建構元當父類別裡沒有建構元時, 表示將採用預設建構元 ( 即沒有參數的建構元 ) 125

126 10.10 後記 當父類別裡有數個建構元時, 若子類別沒有特別指定, 則內定是呼叫父類別的預設建構元 這種情形下, 在父類別裡必須設計一個沒有參數的建構元若父類別裡除了沒有參數的建構元外, 還有其他的建構元, 那麼在子類別中可以用 super() 來指定所要的建構元 且 super() 敘述必須放在建構元程式區塊的第一行 使用上可遵守以下原則 : 父類別要有一個沒有帶參數的建構元子類別可以透過 super() 來呼叫父類別中特定的建構元 super() 必須放在建構元程式區塊裡的第一行敘述 126

127 10.10 後記 子類別可以重新改寫從父類別繼承而來的方法, 並且, 在同一個類別裡的方法也可以多載 抽象類別用來強迫子類別改寫父類別的方法 抽象類別用來定義一個範本 ( 即抽象方法 ), 然後強迫子類別依照這個範本來實作程式碼使用抽象類別時必須留意 : 不能直接用抽象類別來建立物件, 而是要透過抽象類別的子類別來建立物件抽象類別裡的抽象方法不可以宣告為 private, 否則子類別便無法繼承該方法了 127

128 10.10 後記 extends 只允許繼承自單一類別, 如果要繼承自多個類別就必須將父類別宣告為 interface( 介面 ), 然後在子類別裡來實作之介面是一種特殊的類別, 類別 介面都是一種抽象的資料型別類別庫 ( 或稱套件 ) 是程式寶庫, 是程式再利用的基礎 善用類別庫可以縮短程式開發時程, 降低程式維護成本 128