Microsoft Word - Part_V_JavaOOP.doc

Web Development Part V Java 物 件 導 向 設 計 i Table of Content 物 件 與 類 別... 1 物 件 (Object)... 1 類 別 (Class)... 1 public private 與 protected... 2 類 別 的 組 成 - 建 構 子 動 態 實 例 方 法 與 靜 態 類 別 方 法... 2 建 構 子 (Constructors)... 2 實 例 方 法 程 序 (Instance Methods)... 2 類 別 方 法 程 序 (Class Methods)... 3 方 法 程 序 的 重 載 (Overload)... 6 參 數 傳 遞 與 變 數 範 圍... 8 繼 承 (Inheritance) 與 覆 寫 (Override)... 8 繼 承 (Inheritance)... 8 複 寫 (Override) 和 隱 藏 (Hide)... 9 抽 象 (Abstract) 類 別 與 多 形 (Polymorphism)... 14 常 數 (final)... 14 抽 象 類 別 (abstract)... 17 多 形 (Polymorphism)... 19 介 面 (Interface) 與 套 件 (Package)... 21 介 面 (Interface)... 21 套 件 (Package)... 26 執 行 緒 概 念 (Threads)... 31 泛 型 類 別 (Generic Class)... 39 泛 型 的 概 念... 39 泛 型 的 應 用... 39

Web Development Part V Java 物 件 導 向 設 計 1 物 件 與 類 別 物 件 (Object) 物 件 是 一 種 電 腦 程 式 中 自 我 存 在 的 元 素, 又 稱 之 為 生 存 物 件 (instance), 代 表 各 種 相 關 連 的 型 態 群 組, 用 以 完 成 整 個 程 式 設 計 的 任 務 物 件 使 用 變 數 儲 存 狀 態 稱 之 為 屬 性 (Property) 或 實 例 變 數 (Instance Variable), 而 各 種 行 為 的 程 序 和 函 數 則 稱 之 為 方 法 (Method) 物 件 的 屬 性 或 成 員 以 句 點. 描 述 之 Java 的 物 件 是 以 類 別 來 建 立, 是 一 種 可 由 使 用 者 自 行 定 義 的 資 料 型 態 類 別 (Class) 類 別 是 一 種 用 來 建 立 具 有 多 個 物 件 型 態 的 樣 版 (template) 同 一 支 程 式 裡 可 以 有 不 同 的 類 別, 但 只 能 有 一 個 類 別 被 宣 告 為 public, 此 即 主 體 類 別, 表 示 可 以 由 外 部 程 式 呼 叫, 未 宣 告 為 public 的 類 別 則 僅 能 由 程 式 內 部 類 別 呼 叫, 程 式 之 主 體 類 別 名 稱 必 須 和 其 儲 存 檔 案 之 主 檔 名 相 同 類 別 的 宣 告 是 物 件 的 原 型 宣 告, 可 分 為 兩 部 分 : 成 員 資 料 (Data Member): 物 件 的 資 料 部 分, 属 於 基 本 資 料 型 態 的 變 數 常 數 或 其 他 物 件 的 成 員 變 數 (Member Variables) 成 員 方 法 (Method Member): 物 件 的 操 作 部 分, 即 程 式 的 函 數 類 別 在 宣 告 後 得 以 建 立 物 件, 語 法 如 下 : class 類 別 名 稱 { [ 建 構 子 ] 存 取 敘 述 修 飾 子 資 料 型 態 成 員 資 料 ; 存 取 敘 述 修 飾 子 傳 回 值 型 態 成 員 方 法 ( 參 數 列 ) { 程 式 敘 述 ; 如 類 別 中 存 在 主 程 式, 則 主 程 式 起 始 位 置 之 字 串 public static void main(string[] args) 為 保 留 型 態, 不 得 任 意 更 改 建 構 子 為 其 他 程 式 要 使 用 此 類 別 宣 告 物 件 變 數 時 首 先 使 用 到 的 成 員 資 料, 必 須 為 public 支 存 取 修 飾 子, 如 省 略 的 話, 則 會 預 設 為 空 的 建 構 子, 如 public class_name() {

Web Development Part V Java 物 件 導 向 設 計 2 public private 與 protected 存 取 敘 述 修 飾 子 public, private, protected 等, 定 義 類 別 中 各 成 員 資 料 或 方 法 的 生 命 週 期, public 表 示 為 公 用 變 數, 其 他 類 別 中 宣 告 為 此 類 別 的 物 件 變 數 都 可 以 使 用 ; private 表 示 為 私 用 變 數, 僅 提 供 此 類 別 內 之 成 員 變 數 呼 叫 使 用 ; protected 表 示 屬 於 同 一 套 件 (package) 的 類 別 間 可 相 互 呼 叫, 在 不 同 package 則 不 得 使 用 ; 若 未 定 義, 則 僅 限 於 類 別 內 部 使 用, 否 則 要 加 上 static 成 為 靜 態 資 料 或 方 法 類 別 的 組 成 - 建 構 子 動 態 實 例 方 法 與 靜 態 類 別 方 法 建 構 子 (Constructors) 讓 類 別 在 被 呼 叫 時 可 以 傳 入 參 數 建 構 子 之 名 稱 必 須 與 所 屬 類 別 之 名 稱 相 同 ; 建 構 子 無 回 傳 資 料 ( 內 容 無 return), 宣 告 中 亦 不 得 前 置 void; 建 構 子 主 要 功 能 是 在 所 屬 類 別 產 生 新 物 件 時 作 初 始 化 動 作 建 構 子 的 數 目 可 以 不 只 一 個, 亦 即 可 利 用 相 同 名 稱 的 建 構 子 賦 予 不 同 的 傳 入 引 數, 讓 類 別 所 提 供 的 方 法 可 以 更 有 彈 性 的 使 用 不 同 的 參 數 進 行 各 種 資 料 運 算 建 構 子 的 宣 告 方 式 如 下, 其 中 參 數 列 可 以 無 任 何 引 數 public 類 別 名 稱 ( 參 數 列 ) { 程 式 敘 述 ; 實 例 方 法 程 序 (Instance Methods) 實 例 方 法 程 序 屬 於 動 態 方 法, 當 方 法 程 序 所 屬 之 物 件 尚 未 產 生 之 前, 該 方 法 程 序 無 法 執 行, 故 須 先 作 物 件 的 宣 告 方 可 使 用 例 如 宣 告 陣 列 時 必 須 利 用 new 來 產 生 一 個 新 的 陣 列 物 件 敘 述 方 法 如 下 : 存 取 敘 述 傳 回 值 型 態 方 法 名 稱 ( 參 數 列 ) { 程 式 敘 述 ; 存 取 敘 述 -public, private, protected 等, 定 義 該 方 法 的 生 命 週 期 若 有 無 傳 回 值 時, 僅 是 利 用 方 法 程 序 進 行 某 種 運 算, 則 傳 回 值 型 態 為 void 若 是 有 傳 回 值 時, 傳 回 值 型 態 使 用 int 或 char 等 數 值 或 字 串 之 類 的 資 料 型 態, 此 時 的 方 法 便 稱 為 函 數 (Functions), 方 法 的 程 式 區 塊 內 部 要 利 用 return

Web Development Part V Java 物 件 導 向 設 計 3 指 令 傳 回 一 個 符 合 方 法 資 料 型 態 的 傳 回 值 類 別 方 法 程 序 (Class Methods) 類 別 方 法 程 序 或 稱 為 靜 態 方 法 (Static Method), 宣 告 時 須 前 置 static- 利 用 此 修 飾 子, 表 示 靜 置 於 記 憶 體 中, 此 方 法 便 屬 於 此 類 別 本 身, 不 必 另 作 物 件 的 宣 告 即 可 直 接 使 用 例 如 在 前 述 之 主 程 式 中 呼 叫 的 類 別 方 法 或 副 程 式, 或 是 Math 類 別 物 件 所 提 供 的 數 學 函 數, 或 是 利 用 System 類 別 的 out.println 方 法 列 印 資 料, 均 不 需 另 外 宣 告 便 可 直 接 呼 叫 使 用 敘 述 語 法 如 下 ( 除 了 static 外, 其 餘 均 和 Instance Method 一 樣 ): 存 取 敘 述 static 傳 回 值 型 態 方 法 名 稱 ( 參 數 列 ) { 程 式 敘 述 ; this-this 在 程 式 應 用 上 帶 來 許 多 方 便 其 意 義 為 所 屬 類 別 之 代 名 詞 this 可 用 於 建 構 子 間 之 呼 叫 : 使 用 this 呼 叫 建 構 子 時, 僅 可 在 一 建 構 子 中 呼 叫 另 一 建 構 子 ; this 之 statement 必 須 置 於 第 一 行 否 則 為 錯 誤 編 輯 this 可 用 於 成 員 方 法 中 區 別 與 引 數 同 名 的 成 員 資 料 假 設 成 員 資 料 中 已 經 存 在 一 個 變 數 名 稱 name, 而 成 員 方 法 或 建 構 子 中 所 傳 進 來 的 引 數 也 叫 作 name, 此 時 this.name 就 代 表 類 別 中 的 成 員 name, 以 和 引 數 name 做 區 隔 建 立 類 別 範 例 - 提 供 二 手 車 的 引 擎 號 碼 顏 色 代 號 製 造 商 型 號 及 里 程 數 class Car { // 定 義 類 別 內 在 成 員 資 料 private long enginenum ; private int color ; private String model ; private double mileage ; private String brand ; // 預 設 空 建 構 子, 不 需 傳 入 引 數 public Car() { // 需 要 傳 入 引 數 的 建 構 子 public Car(int enginenum, int color, String model, int miles, String brand) { // 利 用 this 賦 予 和 引 數 同 名 的 內 在 成 員 資 料 初 始 值 this.enginenum = enginenum ; this.color = color ;

Web Development Part V Java 物 件 導 向 設 計 4 this.model = model ; this.mileage = miles ; this.brand = brand ; // 實 例 方 法 : 設 定 引 擎 號 碼 public void setenginenum (long num) { enginenum = num ; // 實 例 方 法 : 設 定 車 款 public void setmodel(string id) { model = id ; // 實 例 方 法 : 設 定 車 殼 顏 色 代 碼 public void setcolor (int color) { this.color = color ; // 實 例 方 法 : 設 定 里 程 數 public void setmileage(double miles) { mileage = miles ; // 實 例 方 法 : 設 定 製 造 商 public void setbrand(string name) { brand = name ; // 實 例 方 法 : 取 得 引 擎 號 碼 public long getenginenum() { return enginenum; // 實 例 方 法 : 取 得 顏 色 代 碼 public int getcolor() { return color; // 實 例 方 法 : 取 得 車 型 款 式 public String getmodel() { return model; // 實 例 方 法 : 取 得 里 程 數 public double getmileage() {

Web Development Part V Java 物 件 導 向 設 計 5 return mileage; // 實 例 方 法 : 取 得 製 造 商 public String getbrand() { return brand; // 類 別 方 法 : 傳 回 出 產 國 public static String getnation() { String nation = "Made in Japan" ; return nation ; // 實 例 方 法 : 列 印 二 手 車 資 訊 public void printvehicle () { System.out.println("The Manufactor is " + getbrand()) ; System.out.println("The Model is " + model) ; System.out.println("Color Number is " + color) ; System.out.println("Engine Number is " + getenginenum()) ; System.out.println("Mileage is " + mileage) ; 利 用 主 程 式 呼 叫 類 別 及 執 行 結 果 public class ClassTest { public static void main(string[] args) { // 取 得 靜 態 類 別 方 法 System.out.println(Car.getNation()) ; // 宣 告 類 別 物 件 並 傳 入 資 料 Car car = new Car(82250080, 3, "Wish", 75008, "Toyota") ; car.printvehicle() ; // 取 得 二 手 車 資 訊 // 設 定 新 的 資 訊 car.setbrand("honda") ; car.setmodel("accord") ; car.setmileage(59225) ; car.setenginenum(72320415) ; car.setcolor(0) ; // 取 得 靜 態 類 別 資 訊 不 需 宣 告 類 別 物 件 System.out.println(Car.getNation()) ; car.printvehicle() ; // 取 得 新 的 二 手 資 訊 // 定 義 新 的 類 別 物 件

Web Development Part V Java 物 件 導 向 設 計 6 Car suv = new Car() ; suv.setbrand("nissan") ; suv.setmodel("x-trail") ; System.out.println(suv.getNation()) ; // 以 類 別 物 件 取 得 靜 態 類 別 方 法 資 訊 suv.printvehicle() ; -------------------------------------- 執 行 結 果 ---------------------------- Made in Japan <- 靜 態 類 別 資 料 The Manufactor is Toyota The Model is Wish Color Number is 3 -> 第 一 次 傳 入 的 資 訊 Engine Number is 82250080 Mileage is 75008.0 Made in Japan <- 靜 態 類 別 資 料 The Manufactor is Honda The Model is Accord Color Number is 0 -> 第 二 次 傳 入 的 資 訊 Engine Number is 72320415 Mileage is 59225.0 Made in Japan <- 靜 態 類 別 資 料 The Manufactor is Nissan -> 新 定 義 的 類 別 物 件 The Model is X-Trail Color Number is 0 -> 未 傳 入 引 數 者 會 傳 回 空 值 或 0 Engine Number is 0 Mileage is 0.0 方 法 程 序 的 重 載 (Overload) 如 同 建 構 子 可 以 相 同 名 稱 傳 入 不 同 型 態 的 變 數, 方 法 程 序 亦 具 備 這 樣 的 功 能, 即 為 重 載 重 載 之 定 義 為, 在 同 一 類 別 內 有 兩 個 ( 含 ) 以 上 之 方 法 程 序 具 有 相 同 之 名 稱, 但 其 宣 告 之 類 型 或 參 數 個 數 卻 不 相 同, 但 不 可 以 出 現 有 相 同 名 稱 與 引 數 卻 有 不 同 類 型 宣 告 的 方 法 程 序 ( 如 此 的 覆 載 邏 輯 將 使 電 腦 無 法 判 別 該 使 用 哪 一 個 方 法 ) Example- // 類 別 部 份 class MeanValue { public MeanValue() {

Web Development Part V Java 物 件 導 向 設 計 7 public double mean(double a, double b) { // 1. double c = Math.sqrt(a*a + b*b) ; return c ; public double mean(double[] a) { // 1. double c = 0.0 ; for(int i=0; i<a.length; i++) { c = c + a[i]*a[i] ; return Math.sqrt(c) ; public int mean(double[] a, double[] b) { // 1. double c = 0.0 ; for(int i=0; i<a.length; i++) { c = c + a[i]*b[i] ; return (int)math.sqrt(c) ; // 測 試 主 程 式 部 份 public class OverLoadTest { public static void main(string[] args) { // 2. MeanValue mv = new MeanValue() ; double a = 1.5, b = 2.3 ; double[] c = {1.1, 2.2, 3.3, 4.4, 5.5 ; double[] d = {6.6, 7.7, 8.8, 9.9, 11.11 ; System.out.println(mv.mean(a, b)) ; System.out.println(mv.mean(c)) ; System.out.println(mv.mean(c, d)) ; --------------------------------- 執 行 結 果 ------------------------------- Method 1: 2.745906043549196 Method 2: 8.15781833580523 Method 3: 12 註 解 : 1. 類 別 中 計 算 均 值 的 三 個 Method 具 有 相 同 之 名 稱 mean, 但 其 宣 告 之 資 料 型 態 不 盡 相 同, 有 int, 也 有 double; 且 輸 入 的 引 數 也 都 不 一 樣, 有 純 量, 也 有 陣 列 三 個

Web Development Part V Java 物 件 導 向 設 計 8 Method 分 別 做 不 一 樣 的 運 算, 且 傳 回 不 一 樣 的 值 2. 當 主 程 式 呼 叫 此 Method 時, 則 視 引 數 型 態 來 決 定 使 用 哪 一 個 mean 方 法 參 數 傳 遞 與 變 數 範 圍 區 塊 內 的 變 數 範 圍 (Scope), 亦 可 分 為 類 別 的 成 員 變 數 方 法 參 數 和 區 域 變 數, 變 數 範 圍 會 影 響 其 變 數 值 的 存 取 Class class_name 成 員 變 數 範 圍 { Member Variable Scope ; public void method_name( ) { 方 法 參 數 範 圍 Local Variable Scope ; 區 域 變 數 範 圍 區 域 變 數 範 圍 (Local Variable Scope)- 在 方 法 內 宣 告 的 變 數, 變 數 只 能 在 宣 告 程 式 碼 後 的 程 式 碼 使 用 ( 不 包 括 在 宣 告 前 ), 在 方 法 外 的 程 式 碼 無 法 存 取 此 變 數 方 法 參 數 範 圍 (Method Parameter Scope)- 這 是 傳 入 方 法 的 參 數 列, 其 範 圍 是 整 個 方 法 的 程 式 區 塊, 在 方 法 外 的 程 式 碼 無 法 存 取 成 員 變 數 範 圍 (Member Variable Scope)- 不 論 是 static 宣 告 的 類 別 變 數 或 沒 有 宣 告 static( 物 件 的 實 例 變 數 ), 在 整 個 類 別 的 程 式 碼 都 可 以 存 取 此 範 圍 的 變 數 繼 承 (Inheritance) 與 覆 寫 (Override) 繼 承 (Inheritance) 繼 承 (Inheritance) 讓 類 別 得 以 包 含 現 存 類 別 的 部 分 或 全 部 成 員 資 料 和 成 原 方 法, 且 可 新 增 成 員 或 方 法, 甚 至 覆 載 或 隱 藏 繼 承 類 別 的 方 法 或 變 數 Java 的 類 別 都 是 繼 承 Object 這 個 宗 祖 類 別, 意 即 Java 所 宣 告 的 類 別 都 是 屬 於 Object 類 別 的 子 類 別 子 類 別 (Subclass) 或 延 伸 類 別 (Derived Class): 繼 承 其 他 的 類 別 父 類 別 (Superclass) 或 基 礎 類 別 (Base Class): 被 繼 承 的 別 兄 弟 類 別 (Sibling Class): 彼 此 共 同 繼 承 一 個 父 類 別 的 子 類 別 Vehicle Truck Car Motorcycle Sedan

Web Development Part V Java 物 件 導 向 設 計 9 以 上 圖 之 車 系 為 例, 交 通 工 具 父 類 別 擁 有 卡 車 (Truck) 汽 車 (Car) 機 車 (Motorcycle) 等 三 個 子 類 別, 而 汽 車 對 轎 車 (Sedan) 而 言 則 亦 是 父 類 別, 故 在 Car 類 別 中 可 定 義 如 色 彩 (color) 引 擎 號 碼 (enginenum) 等 成 員 資 料 或 方 法, 則 在 Sedan 子 類 別 中, 可 利 用 extends 語 法 繼 承 Car 父 類 別 所 定 義 的 各 種 屬 性 : class 子 類 別 名 稱 extends 父 類 別 名 稱 { // 額 外 的 成 員 資 料 和 方 法 例 如,Sedan 子 類 別 的 成 員 除 了 繼 承 Car 類 別 所 定 義 的 各 種 資 料, 亦 可 增 加 顯 示 各 種 房 車 售 價 ( 頂 級 中 級 或 入 門 級 價 位 ) 與 車 門 樣 式 ( 兩 門 三 門 四 門 五 門 ) 資 訊 的 成 員, class Car { private long enginenum ; private int color ; public void setenginenum(long num) { enginenum = num ; public void setcolor(int color) { this.color = color ; public void printvehicle() { class Sedan extends Car { private int door ; private double price ; public void setdoor(int door) {this.door = door ; public void setprice(double price) {this.price = price ; 繼 承 的 限 制 條 件 子 類 別 不 能 存 取 父 類 別 宣 告 成 private 的 成 員 資 料 和 方 法 父 類 別 的 建 構 子 不 屬 於 子 類 別, 所 以 子 類 別 不 可 以 繼 承 父 類 別 的 建 構 子, 但 可 以 呼 叫 父 類 別 的 建 構 子 每 個 子 類 別 只 能 繼 承 一 個 父 類 別 複 寫 (Override) 和 隱 藏 (Hide) 當 父 類 別 所 定 義 的 方 法 不 適 用 於 子 類 別 時, 可 利 用 覆 寫 (Override) 的 概 念 在 子 類 別 宣 告 同 名 同 參 數 及 同 傳 回 值 但 方 法 流 程 不 同 的 方 法 來 取 代 ; 然 而 物 件 的 實 例 方 法 (Instance Method) 並 不 能 取 代 宣 告 成 static 的 類 別 方 法 (Class Method), 因 此 如 欲 取 代 父 類 別 的 類 別 方 法 時, 子 類 別 需 要 宣 告 同 樣 的 類 別 方 法 來 取 代, 即 隱 藏 (Hide) 下 例 中,Car 父 類 別 中,getNation() 為 Class Method,printVehicle() 為 動 態 的

Web Development Part V Java 物 件 導 向 設 計 10 實 例 方 法 (Instance Method), 因 此 當 Vehicle 子 類 別 繼 承 Car 父 類 別 的 成 員 後 想 要 對 這 些 方 法 作 修 改, 前 者 必 須 用 Hide 的 方 式 ( 即 成 員 方 法 中 也 要 加 上 static 宣 告 ), 而 後 者 則 用 Override 的 方 式, 此 時 若 在 主 程 式 碼 中 宣 告 變 數 為 此 子 類 別 的 物 件 時, 所 使 用 的 成 員 方 法 就 不 再 是 原 父 類 別 的 方 法 了 此 外, 父 類 別 的 成 員 資 料 也 可 以 在 子 類 別 中 做 隱 藏 的 動 作, 例 如 例 中 Car 父 類 別 中 的 color 成 員 在 Sedan 子 類 別 中 被 隱 藏 原 來 的 屬 性 而 變 成 public String 但 是, 父 類 別 內 的 動 態 實 例 方 法 雖 然 可 以 被 覆 寫, 卻 不 能 像 成 員 資 料 或 靜 態 方 法 那 樣 被 隱 藏, 亦 即 要 改 變 動 態 實 例 方 法 的 資 料 型 態, 必 須 在 同 一 個 類 別 內 的 使 用 覆 載 (Overload) 概 念 來 處 理 class Car { public static String getnation() { 運 算 A public void printvehicle() { 運 算 AA private int color ; class Sedan extends Car { public static String getnation() { 運 算 B public void printvehicle() { 運 算 BB public String color ; 利 用 super 呼 叫 父 類 別 的 建 構 子 - 子 類 別 不 可 以 繼 承 父 類 別 的 建 構 子, 需 要 使 用 時, 用 super 指 令 來 呼 叫 ; 同 理, 子 類 別 內 覆 寫 和 隱 藏 的 成 員 變 數 也 可 以 使 用 super 來 呼 叫 Example- 建 立 子 類 別 Sedan 繼 承 並 複 寫 父 類 別 Car class Sedan extends Car { /** Creates a new instance of Sedan */ public Sedan(){ // 1. super() ; public Sedan(int color) { // 1. super() ; this.setcolor(color) ; private double price ; // 2. private int door ; // 2.

Web Development Part V Java 物 件 導 向 設 計 11 public String color ; // 3. public static String getnation() { // 3. String nation = "Assembled in Taiwan" ; return nation ; public double getprice() { return price; public void setprice(double price) { this.price = price; public int getdoor() { return door; public void setdoor(int door) { this.door = door; public void setcolor(int color) { // 1. super.setcolor(color) ; switch(super.getcolor()) { case 1: this.color = "red"; break ; case 2: this.color = "black" ; break ; case 3: this.color = "green"; break ; case 4: this.color = "blue"; break ; case 5: this.color = "silver"; break ; case 6: this.color = "golden" ; break ;

Web Development Part V Java 物 件 導 向 設 計 12 default: this.color = "white"; public void printvehicle() { // 4. System.out.println("The Manufactor is " + getbrand()) ; System.out.println("The Model is " + super.getmodel()) ; System.out.println("The Door Number is " + door) ; System.out.println("The Color is " + color) ; System.out.println("Engine Number is " + super.getenginenum()) ; System.out.println("Mileage is " + super.getmileage()) ; System.out.println("The Price is " + price) ; // 測 試 類 別 之 主 程 式 部 份 public class InheritOverrideTest { public static void main(string[] args) { Car car = new Car() ; // 5. car.setbrand("nissan") ; car.setmodel("x-trail") ; car.setcolor(6) ; car.setenginenum(22053366) ; car.setmileage(59550) ; System.out.println("Before inheriting and overriding...") ; System.out.println("The car is " + car.getnation()) ; car.printvehicle() ; Sedan nissan = new Sedan(5) ; // 6. nissan.setenginenum(22053366) ; nissan.setmodel("x-trail") ; nissan.setbrand("nissan") ; nissan.setmileage(60000) ; nissan.setcolor(6) ; // 6. nissan.setprice(69900) ; nissan.setdoor(5) ; System.out.println("After inheriting and overriding...") ; System.out.println("The sedan is " + nissan.getnation()) ; nissan.printvehicle() ; nissan.color = "red"; // 7.

Web Development Part V Java 物 件 導 向 設 計 13 System.out.println("After modifing public variable...") ; nissan.printvehicle() ; 註 解 : 1. 繼 承 類 別 class Car 為 設 置 父 類 別, 其 中 含 有 color 變 數 以 供 輸 入 顏 色 代 號 ; class Sedan 為 繼 承 Car 的 子 類 別, 定 義 了 兩 種 建 構 子 : 其 中 一 種 需 要 輸 入 Car 類 別 所 使 用 的 顏 色 代 碼, 兩 種 建 構 子 均 利 用 super() 指 令 呼 叫 父 類 別 的 Car 建 構 子, 以 期 在 子 類 別 中 可 以 使 用 父 類 別 所 提 供 的 方 法 並 建 立 且 覆 寫 Car 類 別 之 setcolor() 方 法, 覆 寫 後 的 setcolor() 中 利 用 switch 控 制 流 程 將 顏 色 代 碼 color 值 轉 為 顏 色 字 串, 因 此 當 color 的 整 數 代 碼 透 過 super.setcolor(color) 在 父 類 別 被 定 義 後, 再 透 過 super.getcolor() 傳 回 子 類 別 內, 並 將 名 稱 相 同 型 態 不 同 的 變 數 改 為 顏 色 的 名 稱 如 使 用 有 傳 入 顏 色 代 碼 的 建 構 子, 便 直 接 執 行 此 方 法 ; 如 使 用 空 建 構 子, 則 要 另 外 執 行 此 方 法 來 傳 回 顏 色 名 稱 2. Sedan 子 類 別 自 行 定 義 的 建 構 子 中 利 用 隱 藏 的 方 式 使 用 與 父 類 別 相 同 名 稱 的 類 別 變 數 color, 並 改 為 public 成 員 ( 可 由 呼 叫 的 程 式 從 外 部 設 定 其 值 ) 3. 在 子 類 別 中 隱 藏 父 類 別 的 靜 態 方 法 getnation(), 將 輸 出 的 字 串 改 變 4. 在 子 類 別 中 覆 寫 父 類 別 的 動 態 方 法 printvehicle(), 除 印 出 父 類 別 中 既 有 的 成 員 資 料, 再 加 印 自 己 本 身 新 增 的 資 料 : 車 門 數 目 顏 色 名 稱 及 售 價 5. 主 程 式 中 首 先 宣 告 父 類 別 Car 的 物 件 變 數, 賦 予 相 關 資 料 並 印 出 6. 在 主 程 式 中 宣 告 子 類 別 Sedan 的 物 件 變 數, 延 用 繼 承 自 父 類 別 的 方 法 輸 入 資 料, 再 利 用 子 類 別 新 增 的 方 法 輸 入 資 料 雖 然 呼 叫 建 構 子 時 有 設 定 了 顏 色 代 碼 為 5, 但 後 續 又 呼 叫 了 setcolor 方 法 將 代 碼 改 為 6, 建 構 子 的 顏 色 輸 入 值 將 被 新 值 覆 蓋 7. 有 別 於 setcolor 方 法, 直 接 利 用 子 類 別 重 新 定 義 的 color 變 數 給 予 新 的 顏 色 名 稱, 再 印 出 車 輛 資 料 執 行 結 果 如 下 : Before inheriting and overriding... The car is Made in Japan ----------------------- 父 類 別 的 靜 態 方 法 輸 出 值 The Manufactor is Nissan The Model is X-Trail Color Number is 6 Engine Number is 22053366 Mileage is 59550.0 After inheriting and overriding... The sedan is Assembled in Taiwan ----------- 被 子 類 別 隱 藏 掉 後 的 靜 態 方 法 輸 出 值 The Manufactor is Nissan The Model is X-Trail

Web Development Part V Java 物 件 導 向 設 計 14 The Door Number is 5 -------------------------- 新 增 加 的 子 類 別 資 料 The Color is golden ------------------------------- 對 應 顏 色 代 碼 後 的 顏 色 名 稱 Engine Number is 22053366 Mileage is 60000.0 The Price is 69900.0 ------------------------------ 新 增 加 的 子 類 別 資 料 After modifing public variable... The Manufactor is Nissan The Model is X-Trail The Door Number is 5 The Color is red ------------------------------------ 改 變 後 的 顏 色 名 稱 Engine Number is 22053366 Mileage is 60000.0 The Price is 69900.0 抽 象 (Abstract) 類 別 與 多 形 (Polymorphism) 常 數 (final) final- 在 程 式 中 宣 告 為 final 的 變 數 視 為 不 可 被 改 變 的 固 定 值 常 數, 只 能 取 出 來 使 用, 但 不 能 變 更 其 值 基 於 保 密 和 設 計 的 原 因, 可 將 類 別 或 其 中 的 方 法 宣 告 成 final, 防 止 被 繼 承 存 取 或 覆 寫 原 類 別 的 操 作 例 如 以 下 之 子 類 別 Customer 可 以 繼 承 Person 父 類 別, 但 因 Customer 被 定 義 成 final, 故 不 能 再 被 任 何 子 類 別 繼 承 ; 而 其 父 類 別 中 有 幾 個 成 員 方 法 也 被 宣 告 成 final, 故 當 Customer 繼 承 Person 時, 並 無 法 覆 寫 這 些 成 員 方 法 的 使 用 權 class Person { final String Lname = Lin ; final char getname() { return name ; final int getage() { return age; final int setname(char c) { name = c ; final void setage(int age) { this.age = age ; final class Customer extends Person { 測 試 final 範 例 class parentclass

Web Development Part V Java 物 件 導 向 設 計 15 { int a ; public parentclass() { System.out.println("Parent: " + getint()) ; final int getint() { setint() ; return a ; final int getinteger() { setinteger() ; return a ; public void setinteger() { this.a = 5 ; // private void setint() // Private member can only be used in parentclass public void setint() { // Public member can be overrided in childclass this.a = 10 ; class childclass extends parentclass { public int b ; public childclass() { super() ; System.out.println("Child: " + this.a) ; System.out.println("Inherit: " + this.getinteger()) ; System.out.println("Override: " + this.getint()) ; setint() ; System.out.println("Child inherit: " + this.a) ; b = this.getint() ; System.out.println("Child variable: " + b) ; public void setint() { this.a = 15 ;

Web Development Part V Java 物 件 導 向 設 計 16 public class finaltest { public static void main(string args[]) { final float a = 2.5f ; // a = a + 1.5f ; // Error: cannot assign a value to final variable a System.out.println("final variable:" + a) ; parentclass p = new parentclass() ; childclass c = new childclass() ; System.out.println("Parent Class: " + p.getint()) ; System.out.println("Child Class: " + c.getint()) ; /* ------------------Results for public void setint() in parentclass:------------- final variable:2.5 Parent: 10 Parent: 15 Child: 15 Inherit: 5 Override: 15 Child inherit: 15 Child variable: 15 Parent Class: 10 Child Class: 15 */ /* ---------------- Results for private void setint() in parentclass: ----------------- final variable:2.5 Parent: 10 Parent: 10 Child: 10 Inherit: 5 Override: 10 Child inherit: 15 Child variable: 10 Parent Class: 10 Child Class: 10 */

Web Development Part V Java 物 件 導 向 設 計 17 抽 象 類 別 (abstract) 宣 告 為 abstract 的 類 別 沒 有 建 構 子, 因 此 不 能 用 來 建 立 物 件, 只 能 用 來 讓 子 類 別 繼 承, 就 像 是 有 身 體 卻 沒 有 頭 部 的 抽 象 形 體, 當 <<abstract>> Shape 類 別 擁 有 抽 象 方 法, 表 示 這 一 定 是 抽 象 類 別 +x:double +y:double 以 右 圖 所 示 之 UML 類 別 圖, 抽 象 類 別 Shape 定 義 了 (x,y) 點 area( ) 座 標 並 提 供 了 計 算 面 積 的 area() 抽 象 方 法 計 算 面 積, 但 此 方 法 不 存 在 程 式 碼 區 塊, 而 利 用 子 類 別 Circle 繼 承 Shape 來 實 作 此 抽 象 方 法 以 計 算 圓 面 積 Circle +r:double 例 中,Circle 除 繼 承 了 Shape 的 x, y 作 為 圓 心 座 標, 亦 新 增 半 徑 r ( 註 : 類 別 圖 中, 上 層 表 類 別 名 稱, 且 以 <<abstract>> area( ) 註 明 為 抽 象 類 別, 第 二 層 為 成 員 變 數, 第 三 層 為 成 員 方 法, 並 分 別 利 用 +, -, # 來 代 表 public, private 及 protected) 抽 象 類 別 雖 然 不 能 建 立 物 件, 但 是 可 以 宣 告 成 參 考 子 類 別 實 例 的 物 件 變 數, 如 Shape c2 = new Circle(10.0, 10.0, 7.0) ; 因 為 Shape 類 別 宣 告 的 物 件 變 數 c2 可 以 參 考 子 類 別 的 實 例, 所 以 Java 程 式 可 以 使 用 instanceof 運 算 子 來 判 斷 物 件 變 數 參 考 的 是 哪 一 個 物 件, 如 if (c2 instanceof Circle) { 如 果 上 式 之 c2 參 考 了 Circle 物 件, 則 會 執 行 區 塊 語 句 由 於 宣 告 成 abstract 的 物 件 只 可 以 參 考, 並 無 法 呼 叫 或 存 取 子 類 別 新 增 的 實 例 變 數 和 方 法, 故 需 要 先 經 過 型 態 轉 換 的 動 作, 例 如 Circle c ; c = (Circle) c2 ; 亦 即 將 原 宣 告 為 抽 象 類 別 Shape 之 物 件 變 數 c2 轉 為 Circle 子 類 別 的 物 件 變 數, 即 可 進 行 存 取 Example abstract class Shape { // Shape 抽 象 類 別 宣 告 public double x; public double y; // 抽 象 方 法 : 計 算 面 積 // X 座 標 // y 座 標 abstract double area(); // 1. class Circle extends Shape { public double r; // 半 徑 public Circle(double x, double y, double r) { this.x = x; this.y = y; this.r = r; // 2. Circle 類 別 宣 告 // 建 構 子

Web Development Part V Java 物 件 導 向 設 計 18 public double area() { // 成 員 方 法 : 實 作 抽 象 方 法 area() return 3.1416*r*r ; // 主 程 式 類 別 public class AbstractTest { public static void main(string[] args) { // 主 程 式 Circle c; // Circle 類 別 的 物 件 變 數 // 宣 告 Circle 類 別 型 態 的 變 數, 並 且 建 立 物 件 Circle c1 = new Circle(5.0, 10.0, 4.0); // 3. Shape c2 = new Circle(10.0, 10.0, 7.0); // 4. // 顯 示 圓 形 c1 的 資 料 System.out.println(" 圓 形 c1 的 資 料 ====="); System.out.println("X 座 標 : " + c1.x); System.out.println("Y 座 標 : " + c1.y); System.out.println(" 半 徑 : " + c1.r); // 呼 叫 物 件 的 實 例 方 法 System.out.println(" 面 積 : " + c1.area()); // 顯 示 圓 形 c2 的 資 料, 檢 查 是 否 為 Circle 的 實 例 if ( c2 instanceof Circle) // 5. System.out.println("----->c2 是 Circle 物 件 "); System.out.println(" 圓 形 c2 的 資 料 ====="); System.out.println("X 座 標 : " + c2.x); System.out.println("Y 座 標 : " + c2.y); c = (Circle) c2; // 6. 型 別 轉 換 System.out.println(" 半 徑 : " + c.r); System.out.println(" 面 積 : " + c2.area()); // 呼 叫 物 件 的 實 例 方 法 註 解 : 1. 抽 象 類 別 的 宣 告, 內 含 抽 象 方 法 area() 2. 繼 承 Shape 類 別 的 Circle 子 類 別, 新 增 變 數 r, 並 實 作 抽 象 方 法 area(); 由 於 繼 承 了 抽 象 類 別 Shape, 於 是 擁 有 了 Shape 內 的 公 開 成 員 變 數 x 和 y 的 使 用 權, 因 此 可 使 用 this.x 與 this.y 取 得 Circle 建 構 子 傳 來 的 引 數 3. 使 用 Circle 類 別 宣 告 物 件 變 數 c1, 然 後 使 用 new 運 算 子 建 立 Circle 物 件 4. 使 用 Shape 類 別 宣 告 物 件 變 數 c2, 然 後 使 用 new 運 算 子 建 立 Circle 物 件 5. if 條 件 檢 查 Shape 類 別 宣 告 的 物 件 變 數 是 否 是 參 考 Circle 物 件 6. 型 態 轉 換 c2 成 為 Circle 類 別 宣 告 的 物 件 變 數, 然 後 顯 示 c.r 實 例 變 數 的 值

Web Development Part V Java 物 件 導 向 設 計 19 多 形 (Polymorphism) Polymorphism 的 目 的 在 讓 應 用 程 式 更 容 易 擴 充, 不 需 要 針 對 不 同 的 資 料 型 態 分 別 建 立 類 別, 而 是 繼 承 一 個 基 礎 類 別 來 建 立 同 名 方 法, 以 處 理 不 同 的 資 料 型 態, 如 果 有 新 的 資 料 型 態, 則 只 須 新 增 繼 承 的 子 類 別 多 型 的 抽 象 類 別 宣 告 : 利 用 上 例 的 觀 念, 建 立 了 Shape 抽 象 類 別 定 義 了 一 個 點 座 標 及 計 算 面 積 用 的 抽 象 方 法 area(), 而 以 Circle 子 類 別 繼 承 之, 可 以 共 用 此 方 法 計 算 圓 面 積, 同 理, 也 可 同 時 建 立 Triangle Rectangle 子 類 別 來 計 算 三 角 形 與 矩 形 的 面 積 abstract class Shape { // Shape 抽 象 類 別 宣 告 public double x; // x 座 標 public double y; // y 座 標 abstract void area(); // 抽 象 方 法 : 計 算 面 積 class Circle extends Shape // Circle 類 別 宣 告 { public void area() { ; // 成 員 方 法 : 實 作 抽 象 方 法 area() 計 算 圓 面 積 class Triangle extends Shape // Triangle 類 別 宣 告 { public void area() { ; // 成 員 方 法 : 實 作 抽 象 方 法 area() 計 算 三 角 形 面 積 class Rectangle extends Shape // Rectangle 類 別 宣 告 { public void area() { ; // 成 員 方 法 : 實 作 抽 象 方 法 area() 計 算 矩 形 面 積 同 名 異 式 的 多 型 方 法 - 在 主 程 式 中 要 使 用 這 些 實 作 抽 象 方 法 計 算 Shape.area() ; Circle 各 種 圖 形 的 面 積, 可 宣 告 Shape 類 別 的 物 件 變 數 s, 接 著 分 別 宣 告 各 圖 形 Circle, Rectangle, Shape.area() ; Triangle 之 類 別 的 物 件 變 數 s1, Ex01_Shapes Rectangle s2, s3, 此 時, 便 可 以 共 同 的 抽 象 方 法 名 稱 area() 計 算 各 種 圖 形 的 面 積 其 中,area() 方 法 就 是 多 形, 一 個 多 形 方 法 在 執 行 時 會 依 照 實 際 參 考 的 物 件 型 態 Shape.area() ; Triangle (Circle.area(), Rectangle.area(), Triangle.area()) 執 行 正 確 的 實 例 方 法

Web Development Part V Java 物 件 導 向 設 計 20 Example abstract class Shape { // Shape 抽 象 類 別 宣 告 public double x; // 成 員 資 料 :X 座 標 public double y; // 成 員 資 料 :y 座 標 // 抽 象 方 法 : 計 算 面 積 abstract double area(); class Circle extends Shape { // Circle 類 別 宣 告 private double r; // 成 員 資 料 : 半 徑 public Circle(double x, double y, double r) { // 建 構 子 this.x = x; this.y = y; this.r = r; public double area() { // 成 員 方 法 : 實 作 抽 象 方 法 area() return 3.1416*r*r ; class Rectangle extends Shape { // Rectangle 類 別 宣 告 private double x1; // 成 員 資 料 :X 座 標 private double y1; // 成 員 資 料 :Y 座 標 public Rectangle(double x, double y, double x1,double y1) { // 建 構 子 this.x = x; this.y = y; this.x1 = x1; this.y1 = y1; public double area() { // 成 員 方 法 : 實 作 抽 象 方 法 area() return (y1-y)*(x1-x) ; class Triangle extends Shape { // Triangle 類 別 宣 告 private double x1; // X 座 標 private double y1; // Y 座 標 private double l; // 三 角 形 底 長 public Triangle(double x, double y, double x1, double y1, double l) { // 建 構 子 this.x = x; this.y = y;

Web Development Part V Java 物 件 導 向 設 計 21 this.x1 = x1; this.y1 = y1; this.l = l; public double area() { // 成 員 方 法 : 實 作 抽 象 方 法 area() return (y1-y)*l/2.0) ; // 主 程 式 類 別 public class PolymorphismTest { public static void main(string[] args) { // 主 程 式 Shape s; // 抽 象 類 別 的 物 件 變 數 // 宣 告 類 別 型 態 的 變 數, 並 且 建 立 物 件 Circle s1 = new Circle(5.0, 10.0, 4.0); Rectangle s2 = new Rectangle(10.0, 10.0, 20.0, 20.0); Triangle s3 = new Triangle(10.0, 10.0, 5.0, 25.0, 5.0); // 呼 叫 抽 象 類 型 物 件 的 抽 象 方 法 area() s = s1; // 圓 形 System.out.println( 圓 面 積 + s.area()); // 1. s = s2; // 長 方 形 System.out.println( 長 方 形 面 積 + s.area()); // 2. s= s3; // 三 角 形 System.out.println( 三 角 形 面 積 + s.area()); // 3. 註 解 : 1. 相 當 於 執 行 Circle.area() ; 2. 相 當 於 執 行 Rectangle.area() ; 3. 相 當 於 執 行 Triangle.area() ; 介 面 (Interface) 與 套 件 (Package) 介 面 (Interface) Java 不 像 C++ 一 樣 能 支 援 一 個 類 別 繼 承 多 個 父 類 別 的 多 重 繼 承 (Multiple Inheritance), 但 是 可 利 用 介 面 的 實 作 來 提 供 相 同 目 的 的 多 重 繼 承 宣 告 介 面 - 介 面 是 在 類 別 繼 承 架 構 中 定 義 類 別 行 為, 內 含 常 數 和 方 法 宣 告, 但 無 實 作 的 程 式 碼, 其 宣 告 的 方 式 與 抽 象 類 別 的 差 別 如 下 : public interface 介 面 名 稱 {

Web Development Part V Java 物 件 導 向 設 計 22 final 資 料 型 態 常 數 = 值 ; 傳 回 值 型 態 介 面 方 法 ( 參 數 列 ) ; 介 面 內 的 數 值 只 能 定 義 常 數, 不 能 定 義 沒 有 值 的 變 數 抽 象 類 別 的 方 法 可 能 只 有 宣 告, 但 是 仍 然 可 以 擁 有 一 般 方 法, 介 面 的 方 法 都 只 有 宣 告, 而 且 一 定 沒 有 實 作 的 程 式 碼 與 類 別 類 似, 同 一 支 程 式 裡 面 可 以 有 好 幾 個 介 面, 但 這 些 介 面 不 能 宣 告 成 為 public, 宣 告 成 public 的 介 面 也 必 須 以 程 式 名 稱 命 名 介 面 不 屬 於 類 別 的 繼 承 架 構, 一 個 介 面 可 以 繼 承 多 個 介 面, 而 毫 無 關 係 的 類 別 也 一 樣 可 以 實 作 同 一 個 介 面 類 別 只 能 繼 承 一 個 抽 象 類 別, 但 是 可 以 同 時 實 作 多 個 介 面, 而 實 作 介 面 中 所 宣 告 的 每 一 個 方 法 都 必 須 予 以 處 理 實 作 介 面 class 類 別 名 稱 implements 介 面 名 稱 1, 介 面 名 稱 2, { // 實 作 介 面 的 方 法 繼 承 介 面 interface 介 面 名 稱 extends 繼 承 的 介 面 1, 繼 承 的 介 面 2 { // 額 外 的 常 數 和 方 法 利 用 前 述 實 作 抽 象 類 別 的 例 <<abstract>> <<interface>> 子, 將 原 先 在 抽 象 類 別 Shape Shape AreaInterface 中 的 area() 方 法 在 介 面 +x:double PI:doube = 3.14159 +y:double AreaInterface 中 宣 告, 接 著 新 增 area() ShapeInterface 介 面 繼 承 AreaInterface, 內 含 計 算 周 長 的 方 法 perimeter() <<interface>> Circle 類 別 在 此 繼 承 Shape 的 Circle ShapeInterface x,y 座 標, 在 植 入 了 介 面 -r:double ShapeInterface 時 獲 得 方 法 +area() +perimeter() perimeter() perimeter(), 並 透 過 其 繼 承 了 AreaInterface 所 定 義 的 常 數 PI 及 方 法 area(), 於 是 新 增 一 個 變 數 r( 圓 半 徑 ) 之 後, 可 計 算 圓 面 積 及 圓 周 長 實 作 介 面 基 本 範 例

Web Development Part V Java 物 件 導 向 設 計 23 // ShapeInterface 介 面 宣 告 interface ShapeInterface { final double PI = 3.1415926; void show(); // Circle 類 別 宣 告 class Circle implements ShapeInterface { private double r; public Circle(double r) { this.r = r; // 實 作 ShapeInterface 中 的 show 方 法 public void show() { System.out.println("PI=" + this.pi) ; // 利 用 getr() 方 法 傳 回 私 有 變 數 r 的 值 public double getr() { return r ; // 主 程 式 類 別 public class InterfaceTest { // 常 數 的 宣 告 // 介 面 方 法 : 印 出 相 關 參 數 // 成 員 資 料 : 半 徑 // 建 構 子 public static void main(string[] args) {// 主 程 式 // 宣 告 Circle 類 別 型 態 的 變 數, 並 且 建 立 物 件 Circle c = new Circle(5.5); System.out.println(" 利 用 類 別 方 法 顯 示 相 關 參 數 ") ; c.show() ; // 顯 示 介 面 的 常 數 值 System.out.println(" 利 用 介 面 取 得 PI 常 數 : " + ShapeInterface.PI); System.out.println(" 利 用 物 件 變 數 取 得 圓 周 率 : " + c.pi) ; System.out.println(" 利 用 物 件 變 數 取 得 圓 半 徑 : " + c.getr()) ; ------------------------------- 執 行 結 果 ---------------------- 利 用 類 別 方 法 顯 示 相 關 參 數 PI=3.1415926 利 用 介 面 取 得 PI 常 數 : 3.1415926 利 用 物 件 變 數 取 得 圓 周 率 : 3.1415926

Web Development Part V Java 物 件 導 向 設 計 24 利 用 物 件 變 數 取 得 圓 半 徑 : 5.5 介 面 及 抽 象 類 別 實 作 範 例 abstract class Shape { // Shape 抽 象 類 別 宣 告 public double x; // X 座 標 public double y; // Y 座 標 interface AreaInterface { // AreaInterface 介 面 宣 告 double area(); // 介 面 方 法 : 計 算 面 積 Interface CircumInterface { // CircumInterface 介 面 宣 告 double perimeter(); // 介 面 方 法 : 計 算 周 長 // ShapeInterface 介 面 宣 告, 繼 承 AreaInterface 與 CircumInterface interface ShapeInterface extends AreaInterface, CircumInterface { final double PI = 3.1415926; // 常 數 的 宣 告 void show(); // 介 面 方 法 : 印 出 相 關 參 數 // Circle 類 別 宣 告 class Circle extends Shape implements ShapeInterface { private double r; // 成 員 資 料 : 半 徑 public Circle(double x, double y, double r) { // 建 構 子 this.x = x; this.y = y; this.r = r; // 實 作 ShapeInterface 所 繼 承 之 AreaInterface 介 面 的 方 法 area() public double area() { return this.pi * this.r * this.r ; // 實 作 ShapeInterface 所 繼 承 之 CircumInterface 介 面 的 方 法 perimeter() public double perimeter() { return 2.0 * this.pi * this.r ; // 實 作 ShapeInterface 中 的 show 方 法 public void show() { System.out.println("PI=" + this.pi) ; System.out.println("r=" + this.r) ; System.out.println("x=" + this.x) ;

Web Development Part V Java 物 件 導 向 設 計 25 System.out.println("y=" + this.y) ; // 利 用 getr() 方 法 傳 回 私 有 變 數 r 的 值 public double getr() { return r ; // 主 程 式 類 別 public class InterfaceTest { public static void main(string[] args) { // 主 程 式 // 宣 告 Circle 類 別 型 態 的 變 數, 並 且 建 立 物 件 Circle c = new Circle(10.0, 7.0, 5.5); // 顯 示 介 面 的 常 數 值 System.out.println(" 利 用 類 別 方 法 顯 示 相 關 參 數 ") ; c.show() ; System.out.println(" 利 用 介 面 取 得 PI 常 數 : " + ShapeInterface.PI); System.out.println(" 利 用 物 件 變 數 取 得 圓 周 率 : " + c.pi) ; System.out.println(" 圓 半 徑 : " + c.getr()) ; System.out.println(" 圓 心 : (" + c.x + ", " + c.y + ")") ; // 呼 叫 物 件 的 介 面 方 法 area() System.out.println(" 圓 面 積 : " + c.area()) ; // 呼 叫 物 件 的 介 面 方 法 perimeter() System.out.println(" 圓 周 長 : " + c.perimeter()) ; ------------------------------- 執 行 結 果 ---------------------- 利 用 類 別 方 法 顯 示 相 關 參 數 PI=3.1415926 r=5.5 x=10.0 y=7.0 利 用 介 面 取 得 PI 常 數 : 3.1415926 利 用 物 件 變 數 取 得 圓 周 率 : 3.1415926 圓 面 積 : 95.03317615 圓 周 長 : 34.5575186 圓 半 徑 : 5.5 圓 心 : (10.0, 7.0)

Web Development Part V Java 物 件 導 向 設 計 26 套 件 (Package) 套 件 (Package)- 將 相 關 的 類 別 和 介 面 集 合 起 來, 可 編 譯 成 套 件, 如 一 般 程 式 所 使 用 的 函 式 庫, 利 用 import 指 令 可 把 套 件 匯 入 程 式 中, 便 可 使 用 套 件 中 所 有 提 供 的 物 件 而 Java 標 準 的 API 即 是 一 個 名 為 java 的 大 套 件, 並 擁 有 數 個 子 套 件 如 lang( 所 有 語 言 基 礎 ) awt( 執 行 GUI 元 件 ) io( 支 援 輸 出 與 輸 入 ) 等 類 別 與 介 面 的 管 理 - 將 原 本 獨 立 的 Java 程 式 宣 告 成 public 的 類 別 或 介 面, 並 將 主 程 式 分 離 出 來, 利 用 javac 編 譯 後, 便 可 形 成 獨 立 的 物 件 檔, 此 時 只 要 單 獨 編 譯 主 程 式 檔, 仍 可 以 達 成 相 同 的 功 能 以 下 範 例 實 作 中 建 立 幾 個 獨 立 的 類 別 與 介 面 : 以 ShapeInterface 父 介 面 宣 常 數 及 計 算 面 積 與 周 長 的 方 法, 讓 Shape 抽 象 類 別 繼 承 並 增 加 參 考 點 座 標 變 數 ; 而 類 別 Circle 及 Rectangle 分 別 實 作 介 面 提 供 面 積 與 周 長 的 計 算, 並 利 用 主 程 式 呼 叫 執 行 : 1. 建 立 介 面 ShapeInterface.java public interface ShapeInterface { // ShapeInterface 介 面 宣 告 final double PI = 3.1415926; // 常 數 的 宣 告 void area(); // 介 面 方 法 : 計 算 面 積 void perimeter(); // 介 面 方 法 : 計 算 周 長 2. 建 立 抽 象 類 別 Shape.java public abstract class Shape { // Shape 類 別 宣 告 public double x; // 成 員 資 料 :X 座 標 public double y; // 成 員 資 料 :Y 座 標 3. 建 立 ㄧ 般 類 別 Circle.java public class Circle extends Shape implements ShapeInterface { private double r; // 成 員 資 料 : 半 徑 public Circle(double x, double y, double r) { // 建 構 子 this.x = x; this.y = y; this.r = r; public void area() { // 實 作 ShapeInterface 介 面 的 方 法 area() System.out.println(" 圓 面 積 : " + PI*r*r); public void perimeter() { // 實 作 ShapeInterface 介 面 的 方 法 perimeter() System.out.println(" 圓 周 長 : " + 2.0*PI*r); 4. 建 立 Rectangle.java

Web Development Part V Java 物 件 導 向 設 計 27 public class Rectangle extends Shape implements ShapeInterface { private double x1; // 成 員 資 料 :X 座 標 private double y1; // 成 員 資 料 :Y 座 標 public Rectangle(double x, double y, double x1, double y1) {// 建 構 子 this.x = x; this.y = y; this.x1 = x1; this.y1 = y1; public void area() { // 實 作 ShapeInterface 介 面 的 方 法 area() System.out.println(" 長 方 形 面 積 : " + (y1-y)*(x1-x)); public void perimeter() { // 實 作 ShapeInterface 介 面 的 方 法 perimeter() System.out.println(" 長 方 形 周 長 : " + 2.0*((y1-y)+(x1-x))); 5. 建 立 含 主 程 式 之 類 別 ShapePackage.java public class ShapePackage { // 主 程 式 public static void main(string[] args) { // 宣 告 Circle 類 別 型 態 的 變 數, 並 且 建 立 物 件 Circle c = new Circle(5.0, 10.0, 4.0); Rectangle r = new Rectangle(5.0,5.0,10.0,10.0); // 呼 叫 物 件 的 介 面 方 法 area() c.area(); r.area(); // 呼 叫 物 件 的 介 面 方 法 perimeter() c.perimeter(); r.perimeter(); 6. 執 行 過 程 D:\Course_Data\Example\PackageTest>javac Shape.java D:\Course_Data\Example\PackageTest>javac ShapeInterface.java D:\Course_Data\Example\PackageTest>javac cp.;d: Circle.java D:\Course_Data\Example\PackageTest>javac cp.;d: Rectangle.java D:\Course_Data\Example\PackageTest>javac cp.;d: ShapePackage.java

Web Development Part V Java 物 件 導 向 設 計 28 D:\Course_Data\Example\PackageTest>java ShapePackage 圓 面 積 : 50.2654816 長 方 形 面 積 : 25.0 圓 周 長 : 25.1327408 長 方 形 周 長 : 20.0 由 於 預 設 的 classpath 只 有 Java 原 始 套 件, 故 自 訂 類 別 時 有 繼 承 其 他 自 定 的 類 別 或 介 面 的 情 況 下, 編 譯 器 會 找 不 到 這 些 類 別 的 位 置, 此 時 可 利 用 -cp 的 編 譯 選 項 將 所 使 用 類 別 之 路 徑 加 上 去 如 果 在 執 行 javac 時 沒 有 使 用 -cp 參 數 設 定 路 徑, 也 可 能 通 過 編 譯 ( 即 如 例 中 所 有 的 程 式 均 在 同 一 個 路 徑 下 ), 但 在 以 java 執 行 程 式 時, 就 必 須 加 上 -cp 的 參 數 設 定 路 徑, 方 可 讓 主 程 式 在 執 行 時 找 到 相 關 的 類 別 檔 其 中, 在 路 徑 之 前 加 上 句 點. ( 或 %classpath%) 的 目 的 是 保 留 原 來 的 已 經 設 定 在 環 境 變 數 下 的 類 別 路 徑, 而 在 此 處 附 加 新 的 類 別 路 徑 上 去 或 者 可 在 進 行 編 譯 前 利 用 set classpath 的 指 令 將 新 的 類 別 路 徑 加 上 去, 例 如, 假 設 程 式 及 類 別 檔 所 在 路 徑 為 D:\Course_Data\Example\PackageTest set CLASSPATH = ".;D:\ Course _Data\Example\PackageTest 設 定 完 後 就 不 需 要 在 編 譯 時 加 上 路 徑 了 建 立 套 件 - 利 用 package 指 令 敘 述, 在 每 個 獨 立 出 來 的 Java 類 別 程 式 前 面 加 上 套 件 名 稱, 即 可 將 這 些 類 別 包 含 到 該 套 件 裡 面 以 上 例 中 之 Shape.java 為 例, 假 如 需 要 包 含 至 套 件 Shapes 中, 則 為 package Shapes ; public abstract class Shape { 編 譯 套 件 的 類 程 式 時, 將 這 些 程 式 集 合 在 同 一 個 目 錄 底 下, 而 該 目 錄 名 稱 即 是 套 件 名 稱, 套 件 名 稱 與 路 徑 和 檔 案 所 在 目 錄 是 彼 此 有 關 聯 的! 套 件 中 的 子 類 別, 如 有 繼 承 父 類 別 或 介 面 的 情 形, 除 非 在 實 體 目 錄 中 也 是 對 應 存 在 於 父 類 別 所 在 之 套 件 目 錄 下 的 自 類 別 中, 在 編 譯 時 要 利 用 javac classpath 指 令 來 指 定 套 件 父 類 別 所 在 位 置 匯 入 套 件 - 利 用 import 指 令 敘 述, 將 所 需 用 到 套 件 中 的 類 別 匯 入 執 行 的 程 式 中 例 如 沿 用 前 例, 套 件 名 稱 為 Shapes, 內 含 被 獨 立 出 來 的 Circle 及 Rectangle 兩 個 類 別, 在 主 程 式 欲 將 此 套 件 類 別 匯 入, 則 有 import Shapes.Circle ; import Shapes.Rectangle ; public class ShapePackage{ public static void main(string[] args) { // 主 程 式

Web Development Part V Java 物 件 導 向 設 計 29 其 中, 亦 可 利 用 import Shapes.* ;, 一 次 把 所 有 的 套 件 類 別 全 部 匯 入 Example- 將 前 例 中 的 類 別 製 作 成 套 件 並 編 譯 執 行 1. 製 作 套 件 Shapes: 令 套 件 中 各 類 別 所 存 在 目 錄 全 名 為 D:\Course_Data\Example\Shapes /* 程 式 範 例 : Shape.java */ package Shapes; public abstract class Shape // Shape 類 別 宣 告 { // 成 員 資 料 public double x; // X 座 標 public double y; // y 座 標 /* 程 式 範 例 : ShapeInterface.java */ package Shapes; public interface ShapeInterface { // 常 數 的 宣 告 final double PI = 3.1415926; // 介 面 方 法 : 計 算 面 積 void area(); // 介 面 方 法 : 計 算 周 長 void perimeter(); /* 程 式 範 例 : Circle.java */ // ShapeInterface 介 面 宣 告 package Shapes; // Circle 類 別 宣 告 public class Circle extends Shape implements ShapeInterface { // 成 員 資 料 private double r; // 半 徑 // 建 構 子 public Circle(double x, double y, double r) { this.x = x; this.y = y; this.r = r; // 實 作 ShapeInterface 介 面 的 方 法 area() public void area() { System.out.println(" 圓 面 積 : " + PI*r*r); // 實 作 ShapeInterface 介 面 的 方 法 perimeter()

Web Development Part V Java 物 件 導 向 設 計 30 public void perimeter() { System.out.println(" 圓 周 長 : " + 2.0*PI*r); /* 程 式 範 例 : Rectangle.java */ package Shapes; // Rectangle 類 別 宣 告 public class Rectangle extends Shape implements ShapeInterface { // 成 員 資 料 private double x1; // X 座 標 private double y1; // Y 座 標 // 建 構 子 public Rectangle(double x, double y, double x1, double y1) { this.x = x; this.y = y; this.x1 = x1; this.y1 = y1; // 實 作 ShapeInterface 介 面 的 方 法 area() public void area() { System.out.println(" 長 方 形 面 積 : " + (y1-y)*(x1-x)); // 實 作 ShapeInterface 介 面 的 方 法 perimeter() public void perimeter() { System.out.println(" 長 方 形 周 長 : " + 2.0*((y1-y)+(x1-x))); 2. 編 譯 套 件 各 類 別 建 立 套 件 : 其 中 Circle 和 Rectangle 兩 個 子 類 別 繼 承 了 Shape 抽 象 類 別 的 變 數 和 ShapeInterface 介 面 的 方 法, 故 須 以 -classpath 或 -cp 指 定 其 套 件 位 置 D:\Course_Data\Example\Shapes>javac Shape.java D:\Course_Data\Example\Shapes>javac ShapeInterface.java D:\Course_Data\Example\Shapes>javac -cp.;d:\course_data\example Circle.java D:\Course_Data\Example\Shapes>javac -cp.;d:\course_data\example Rectangle.java 3. 建 立 匯 入 套 件 類 別 之 主 程 式 import Shapes.* ; // import Shapes.Circle ; // import Shapes.Rectangle ; public class ShapePackage

Web Development Part V Java 物 件 導 向 設 計 31 { // 主 程 式 public static void main(string[] args) { // 宣 告 Circle 類 別 型 態 的 變 數, 並 且 建 立 物 件 Circle c = new Circle(5.0, 10.0, 4.0); Rectangle r = new Rectangle(5.0,5.0,10.0,10.0); // 呼 叫 物 件 的 介 面 方 法 area() c.area(); r.area(); // 呼 叫 物 件 的 介 面 方 法 perimeter() c.perimeter(); r.perimeter(); 4. (a) 編 譯 並 執 行 主 程 式 - 如 主 程 式 恰 好 在 套 件 目 錄 ( 即 Shapes) 上 層 D:\Course_Data\Example>javac -cp.;d:\course_data\example ShapePackage.java D:\Course_Data\Example>java ShapePackage 圓 面 積 : 50.2654816 長 方 形 面 積 : 25.0 圓 周 長 : 25.1327408 長 方 形 周 長 : 20.0 4. (b) 編 譯 並 執 行 主 程 式 - 如 主 程 式 不 在 套 件 目 錄 ( 即 Shapes) 上 層 或 任 意 目 錄 D:\Course_Data\Example\Shapes>javac cp.;d:\course_data\example ShapePackage.java D:\Course_Data\Example\Shapes>java -cp.;d:\course_data\example ShapePackage 圓 面 積 : 50.2654816 長 方 形 面 積 : 25.0 圓 周 長 : 25.1327408 長 方 形 周 長 : 20.0 protected - 宣 告 的 成 員 方 法 或 變 數 可 以 在 同 一 類 別 其 子 類 別 或 同 一 套 件 存 取, 其 存 取 權 限 介 於 publuc 與 private 之 間 public: 擁 有 全 域 變 數, 任 何 類 別 都 可 以 存 取, 包 含 子 類 別 private: 只 可 以 在 同 一 類 別 中 存 取, 不 可 以 在 子 類 別 中 存 取 不 使 用 修 飾 子 : 預 設 範 圍 是 同 一 個 類 別 和 套 件 中 存 取, 但 不 包 含 不 同 套 件 的 子 類 別, 其 存 取 範 圍 比 protected 小, 因 為 protected 可 包 含 不 同 套 件 的 子 類 別 執 行 緒 概 念 (Threads) 執 行 緒 (Threads)- 可 視 為 一 種 Lightweight process ( 輕 量 行 程 ),

Web Development Part V Java 物 件 導 向 設 計 32 能 單 獨 存 在 或 獨 立 執 行, 必 須 隸 屬 一 個 程 式 程 式 啟 動 執 行 緒 後, 可 作 為 幕 後 處 理 (daemon) 將 程 式 分 割 成 多 個 同 步 執 行 緒 一 起 執 行, 稱 之 為 平 行 程 式 設 計 (parallel programming) 單 一 應 用 程 式 擁 有 多 個 執 行 流 程, 稱 之 為 多 執 行 緒 (multithreads), 即 多 工 處 理 建 立 執 行 緒 方 式 實 作 Runnable 介 面 建 立 物 件 類 別 實 作 Runnable 介 面 之 run() 方 法 class ComputeClass { // 一 般 執 行 計 算 的 物 件 類 別 public long sum() {// 計 算 方 法 class ComputeTread extends ComputeClass implements Runnable { // 建 構 子 public ComputeThread( ) { // 實 作 run() 方 法 執 行 執 行 緒 呼 叫 ComputeClass 的 方 法 ( 如 sum) public void run() { public class RunnableTest { // 主 程 式 public static void main(string[] args) { // 建 立 執 行 緒 ComputeThread ct = new ComputeThread( ); Thread t = new Thread(ct); t.start() ; // 啟 動 執 行 緒 繼 承 Thread 類 別 直 接 繼 承 Thread 類 別 複 寫 run() 方 法 class ComputeTread extends Thread { // 建 構 子 public ComputeThread( ) { // 複 寫 run() 方 法 執 行 執 行 緒 public void run() { public class ThreadTest { // 主 程 式

Web Development Part V Java 物 件 導 向 設 計 33 public static void main(string[] args) { // 建 立 執 行 緒 ComputeThread ct = new ComputeThread( ); ct.start() ; // 啟 動 執 行 緒 Thread 物 件 之 建 構 子 與 方 法 建 構 子 Thread() Thread(String) 建 立 Thread 物 件, 參 數 String 是 執 行 緒 名 稱,Runnable 是 Thread(Runnable) 實 作 Runnable 介 面 的 物 件 Thread(Runnable, String) 方 法 int activecount() 取 得 目 前 正 在 執 行 中 的 執 行 緒 數 目 Thread currentthread() 取 得 目 前 的 執 行 緒 物 件 void sleep(long) 讓 執 行 緒 暫 時 停 止 執 行 一 段 時 間, 參 數 long 為 停 滯 的 毫 秒 數 boolean isalive() 檢 查 目 前 執 行 緒 是 否 在 執 行 中, 傳 回 值 true 為 是,false 為 否 void start() 啟 動 執 行 緒 void setname(string) 將 執 行 緒 指 定 為 參 數 String 字 串 的 名 稱 String getname() 取 得 執 行 緒 的 名 稱 字 串 String tostring() 取 得 執 行 緒 名 稱 優 先 權 和 群 組 名 稱 的 字 串, 預 設 執 行 緒 群 組 是 main 以 下 程 式 實 作 Runnable 介 面, 利 用 兩 個 執 行 緒 累 計 執 行 停 滯 時 間 public class RunnableTest { // 主 程 式 : 呼 叫 SumClass 啟 動 執 行 緒 public static void main(string[] args) { System.out.print(" 執 行 緒 : "); System.out.println(Thread.currentThread());// 輸 出 目 前 執 行 緒 物 件 // 建 立 執 行 緒 物 件 SumRunner st1 = new SumRunner(15, 1); Thread t1 = new Thread(st1, " 執 行 緒 A");// 定 義 執 行 緒 1 SumRunner st2 = new SumRunner(20, 2); Thread t2 = new Thread(st2, " 執 行 緒 B");// 定 義 執 行 緒 2 // 啟 動 執 行 緒 t1.start(); t2.start();

Web Development Part V Java 物 件 導 向 設 計 34 class SumClass { private long length = 100;// 進 行 加 總 延 遲 時 間 的 迴 圈 數 ( 預 設 為 100) // 建 構 子 : 宣 告 時 輸 入 要 執 行 加 總 的 迴 圈 數 public SumClass(long length) { this.length = length; public long sum(int threadid) { long temp = 0;// 停 滯 時 間 總 和 for(int i=1; i<=length; i++) { int sleepduration = (int)(math.random()*10);// 隨 機 產 生 停 滯 時 間 try {//Stop running for a short moment Thread.sleep(sleepduration);// 時 間 暫 停 catch (Exception e) { temp += sleepduration; System.out.println(threadID + ":" + i);// 印 出 迴 圈 數 ( 因 啟 動 執 行 緒 平 行 運 算, 執 行 緒 代 號 會 交 互 被 輸 出 ) return temp; class SumRunner extends SumClass implements Runnable { private int threadid; // 建 構 子 : 繼 承 SumClass 中 的 成 員 變 數 (length) public SumRunner(long length, int threadid) { super(length); this.threadid = threadid; // 實 作 執 行 緒 方 法 public void run() { System.out.println(Thread.currentThread() + " 延 遲 時 間 總 和 = " + sum(this.threadid) + " 毫 秒 "); /****************** 執 行 結 果 ****************/ 執 行 緒 : Thread[main,5,main]

Web Development Part V Java 物 件 導 向 設 計 35 2:1 1:1 1:2 2:2 : 1:14 2:17 1:15 Thread[ 執 行 緒 A,5,main] 延 遲 時 間 總 和 = 77 毫 秒 2:18 2:19 2:20 Thread[ 執 行 緒 B,5,main] 延 遲 時 間 總 和 = 84 毫 秒 以 下 程 式 實 作 Thread 類 別, 利 用 兩 個 執 行 緒 累 計 執 行 停 滯 時 間 ( 執 行 結 果 同 上 ) public class ThreadTest { public static void main(string[] args) { System.out.print(" 執 行 緒 : "); System.out.println(Thread.currentThread());// 輸 出 目 前 執 行 緒 物 件 // 建 立 執 行 緒 物 件 SumThread st1 = new SumThread(15, 1, " 執 行 緒 A");// 定 義 執 行 緒 1 SumThread st2 = new SumThread(20, 2, " 執 行 緒 B");// 定 義 執 行 緒 2 // 啟 動 執 行 緒 st1.start(); st2.start(); class SumThread extends Thread { private long length = 100;// 進 行 加 總 延 遲 時 間 的 迴 圈 數 ( 預 設 為 100) private int threadid = 0;// 執 行 緒 編 號, 預 設 為 0 // 建 構 子 : 繼 承 SumClass 中 的 成 員 變 數 (length) public SumThread(long length, int threadid, String name) { super(name); this.threadid = threadid; this.length = length; @Override

Web Development Part V Java 物 件 導 向 設 計 36 public void run() { long temp = 0;// 停 滯 時 間 總 和 for (int i = 1; i <= length; i++) { int sleepduration = (int) (Math.random() * 10);// 隨 機 產 生 停 滯 時 間 try {//Stop running for a short moment Thread.sleep(sleepduration);// 時 間 暫 停 catch (Exception e) { temp += sleepduration; System.out.println(threadID + ":" + i);// 印 出 迴 圈 數 ( 因 啟 動 執 行 緒 平 行 運 算, 執 行 緒 代 號 會 交 互 被 輸 出 ) System.out.println(Thread.currentThread() + " 延 遲 時 間 總 和 = " + temp + " 毫 秒 "); 應 用 執 行 緒 建 立 幕 後 執 行 模 式 自 動 啟 動 命 令 提 示 模 式 下 執 行 的 程 式 建 立 幕 後 程 式, 執 行 指 令 如 : java DaemonFiling 0 test.txt 繼 承 Thread 類 別 並 在 run() 方 法 中 利 用 Runtime 產 生 執 行 緒 使 用 Process 類 別 (exec() 方 法 ) 代 入 幕 後 執 行 指 令 (cmd) RunTime.getRunTime().exec(cmd); import java.io.ioexception; import java.util.scanner; import java.util.logging.level; import java.util.logging.logger; public class DaemonTest extends Thread { private String cmd; public static void main(string[] args) { // 呼 叫 物 件 類 別 並 輸 入 幕 後 執 行 指 令 ( 註 ) DaemonTest run = new DaemonTest("java DaemonFiling 0 test.txt"); try { run.start();//start the thread run.setdaemon(true);//send to daemon catch (Exception e) { System.out.println("Running is terminated because process nothing"); finally {

Web Development Part V Java 物 件 導 向 設 計 37 Scanner sc = new Scanner(System.in); if (run.isalive()) { System.out.println("Running is alive"); if (run.isdaemon()) { System.out.println("Running is in daemon"); if (run.isinterrupted()){ System.out.println("Running is interrupted"); System.out.println("Do you want to stop the thread process(y/n)?"); if(sc.next().tolowercase().charat(0) == 'y') { run.stop(); System.out.println("Stop the thread process"); // 建 構 子 public DaemonTest(String cmd) {// 讀 取 幕 後 執 行 指 令 this.cmd = cmd; System.out.println("Command: " + cmd); @Override public void run() {// 複 寫 run() 方 法 try {// 進 行 幕 後 執 行 程 序 Process proc = Runtime.getRuntime().exec(cmd); catch (IOException ex) {// 例 外 處 理 ( 程 式 碼 為 Netbeans 工 具 自 動 產 生 ) Logger.getLogger(DaemonTest.class.getName()).log(Level.SEVERE, null, ex); ( 註 ): DaemonFiling 類 別 可 讀 取 或 寫 入 一 般 文 字 資 料 檔, 使 用 指 令 如 下 java DaemonFiling 0 test.txt 建 立 或 更 新 test.txt 文 字 檔, 寫 入 現 在 時 間 java DaemonFiling 1 test.txt 刪 除 已 存 在 之 test.txt 文 字 檔 import java.io.file; import java.io.filewriter;

Web Development Part V Java 物 件 導 向 設 計 38 import java.util.date; public class DaemonFiling { public static void main(string[] args) { // java DaemonFiling opt filename try { String opt = args[0]; String filename = args[1]; File f = new File(filename); if (opt.equals("0")) {//Create or Update file FileWriter fw; if (f.exists()) { fw = new FileWriter(f, true); else { fw = new FileWriter(f); Date date = new Date(); fw.write(date.tostring() + "\n");//record current time fw.close(); System.out.println("File is created or updated"); else { if(f.exists()) {//Delete file if file is existing f.delete(); System.out.println("File is deleted or absent"); catch (Exception e) {//Throw the exception information System.out.println("0: Input filename to create or " + "1: output filename to delete is required");

Web Development Part V Java 物 件 導 向 設 計 39 泛 型 類 別 (Generic Class) 泛 型 的 概 念 泛 型 類 別 使 用 時 機 : 定 義 類 別 時, 發 現 到 好 幾 個 類 別 的 邏 輯 其 實 都 相 同, 就 只 是 當 中 所 涉 及 的 型 態 不 一 樣 時, 會 增 加 不 必 要 的 檔 案 管 理 困 擾 可 任 意 使 用 型 態 代 號, 如 <E>, 用 來 宣 告 一 個 型 態 持 有 者 (Holder) E, 之 後 可 以 用 E 作 為 型 態 代 表 來 宣 告 變 數 名 稱 語 法 範 例 public class GenericFoo<E> { private E foo; public void setfoo(e foo) { this.foo = foo; public E getfoo() { return foo; 以 上 類 別 GenericFoo 擁 有 泛 型 資 料 型 態 E, 使 用 時 可 以 以 下 方 式 宣 告 GenericFoo<Boolean> foo1 = new GenericFoo<Boolean>(); GenericFoo<Integer> foo2 = new GenericFoo<Integer>(); foo1.setfoo(new Boolean(true)); Boolean b = foo1.getfoo(); foo2.setfoo(new Integer(10)); Integer i = foo2.getfoo(); 如 果 使 用 泛 型 類 別, 但 宣 告 時 不 一 併 指 定 型 態, 則 預 設 會 使 用 Object, 此 時 要 自 己 轉 換 物 件 的 介 面 型 態 泛 型 的 應 用 應 用 泛 型 類 別 置 入 不 同 資 料 型 態 的 計 算 使 用 一 般 資 料 型 態 public class GenericBasicTest { public GenericBasicTest() { public static void main(string[] args) { // 建 立 泛 型 物 件, 只 允 許 輸 入 整 數 GenericFoo<Integer> foo_i = new GenericFoo<Integer>(); // 建 立 泛 型 物 件, 只 允 許 輸 入 實 數

Web Development Part V Java 物 件 導 向 設 計 40 GenericFoo<Double> foo_d = new GenericFoo<Double>(); foo_i.setfoo(100); foo_d.setfoo(100.0); Integer foo_i1 = foo_i.getfoo(); Double foo_d1 = foo_d.getfoo(); System.out.println(foo_i1 + " <-> " + foo_d1); foo_i.setintegerfoo(100); int foo_i2 = foo_i.getfoo().intvalue();// 取 得 泛 型 物 件 計 算 後 整 數 值 System.out.println(foo_i2); foo_d.setdoublefoo(100.0); double foo_i3 = foo_d.getfoo().doublevalue();// 取 得 泛 型 物 件 計 算 後 實 數 值 System.out.println(foo_i3); int foo_i4 = foo_i.getintegerfoo(100); System.out.println(foo_i4); double foo_i5 = foo_d.getdoublefoo(100.0); System.out.println(foo_i5); // 建 立 泛 型 物 件 class GenericFoo<E> { private E foo; public void setfoo(e foo) { this.foo = foo; public E getfoo() { return foo; public void setintegerfoo(e foo) {// 以 泛 型 計 算 整 數 資 料 this.foo = (E) (Object) (Integer.parseInt(foo.toString()) * 10); public void setdoublefoo(e foo) {// 以 泛 型 計 算 實 數 資 料 this.foo = (E) (Object) (Double.parseDouble(foo.toString()) * Math.PI); public int getintegerfoo(e foo) {// 輸 入 泛 型 資 料 計 算 後 傳 回 整 數 值 return Integer.parseInt(foo.toString()) * 100; public double getdoublefoo(e foo) {// 輸 入 泛 型 資 料 計 算 後 傳 回 實 數 值 return Double.parseDouble(foo.toString()) * Math.PI;

Web Development Part V Java 物 件 導 向 設 計 41 應 用 於 List 抽 象 類 別 import java.util.iterator; import java.util.list; import java.util.arraylist; // 建 立 泛 型 串 列 物 件 public class GenericListTest { // 物 件 建 構 子 public GenericListTest() { // 物 件 主 程 式 public static void main(string[] args) { // 宣 告 List 抽 象 類 別, 只 允 許 輸 入 字 串 String 資 料 // 抽 象 類 別 必 須 透 過 實 體 類 別 實 體 化, 在 此 例 如 ArrayList, LinkedList, Vector 等 等 List<String> alist = new ArrayList<String>(); alist.add("snow"); alist.add(0, "Ball");// 將 下 一 個 字 串 放 在 前 一 個 字 串 之 前, 字 串 依 序 後 推 一 位 Iterator it = alist.iterator();// 宣 告 走 訪 串 列 物 件 while (it.hasnext()) {// 走 訪 串 列 System.out.println(it.next());// 輸 出 走 訪 資 料 GenericListTest glt = new GenericListTest();// 宣 告 泛 型 串 列 物 件 glt.setlist(alist); int[] xx = {1, 2, 3, 4, 5; List blist = glt.getlist(xx); it = blist.iterator(); while (it.hasnext()) { System.out.println(it.next()); // 物 件 方 法 : 輸 入 任 意 型 態 的 List 建 立 串 列 public void setlist(list<?> list) {//<?> 符 號 代 表 所 有 資 料 型 態 均 可 接 受 ( 可 省 略 ) Iterator it = list.iterator(); while (it.hasnext()) { System.out.println("Set: " + it.next());

Web Development Part V Java 物 件 導 向 設 計 42 // 物 件 方 法 : 輸 入 整 數 陣 列 傳 回 整 數 型 態 串 列 public List<Integer> getlist(int[] x) { List<Integer> list = new ArrayList<Integer>();// 宣 告 只 允 許 存 放 整 數 之 串 列 for (int xi : x) {// 利 用 foreach 迴 圈 將 整 數 置 入 串 列 中 list.add(xi * 10); return list; 擴 充 泛 型 類 別 - 繼 承 一 泛 型 類 別, 保 留 其 型 態 持 有 者, 並 新 增 型 態 持 有 者 以 下 範 例 定 義 一 泛 型 的 父 類 別 MainGenericFoo, 接 著 以 子 類 別 SubGenericFoo 繼 承 // 建 立 父 類 別 MainGenericFoo public class MainGenericFoo<T1, T2> { private T1 foo1; private T2 foo2; public void setfoo1(t1 foo1) { this.foo1 = foo1; public T1 getfoo1() { return foo1; public void setfoo2(t2 foo2) { this.foo2 = foo2; public T2 getfoo2() { return foo2; // 建 立 子 類 別 SubGenericFoo.java 擴 充 以 上 之 父 類 別 public class SubGenericFoo<T1, T2, T3> extends GenericFoo<T1, T2> { private T3 foo3; public void setfoo3(t3 foo3) { this.foo3 = foo3; public T3 getfoo3() {

Web Development Part V Java 物 件 導 向 設 計 43 return foo3; // 測 試 以 上 物 件 類 別 public class GenericInheritTest { public static void main(string[] args) { SubGenericFoo<String, Integer, Double> sgf = new SubGenericFoo<String, Integer, Double>();// 宣 告 泛 型 類 別, 指 定 三 種 資 料 型 態 sgf.setfoo1("hello Kitty"); sgf.setfoo2(12); sgf.setfoo3(34.5); System.out.println(sgf.getFoo1() + " earns " + sgf.getfoo3() + " as " + sgf.getfoo2() + " years old"); 實 作 泛 型 介 面 - 實 作 一 泛 型 介 面, 保 留 其 型 態 持 有 者, 並 新 增 型 態 持 有 者 以 下 範 例 定 義 一 泛 型 的 介 面 GenericInterfaceFoo, 接 著 以 類 別 GenericClassFoo 進 行 實 作 // 建 立 介 面 GenericInterfaceFoo interface GenericInterfaceFoo<T1, T2> { public void setfoo1(t1 foo1); public void setfoo2(t2 foo2); public T1 getfoo1(); public T2 getfoo2(); // 建 立 類 別 GenericClassFoo 實 作 GenericInterfaceFoo 介 面 class GenericClassFoo<T1, T2> implements GenericInterfaceFoo<T1, T2> { private T1 foo1; private T2 foo2; public void setfoo1(t1 foo1) { this.foo1 = foo1; public T1 getfoo1() { return foo1;