第 八 章 繼 承 章 節 大 綱. 類 別 繼 承 的 目 的. Object 類 別 課 前 指 引 在 本 章 中, 我 們 將 介 紹 類 別 的 繼 承, 而 在 下 一 章 中 我 們 將 介 紹 一 種 特 殊 的 介 面 類 別, 對 於 一 個 Java 程 式 設 計 師 來 說, 是 相 當 重 要 且 基 本 的 兩 種 技 術, 因 為 它 包 含 了 物 件 導 向 的 三 大 特 性 - 封 裝 繼 承 多 型. 一 般 類 別 的 繼 承. final 修 飾 字 的 用 途. 抽 象 類 別. 本 章 回 顧 備 註 : 可 依 進 度 點 選 小 節. 類 別 繼 承 的 目 的. 一 般 類 別 的 繼 承 物 件 導 向 是 為 了 在 開 發 大 型 程 式 時, 能 夠 更 有 效 率 而 發 展 的 一 套 技 術 因 此 在 物 件 導 向 程 式 設 計 中, 如 何 讓 相 同 的 程 式 碼 被 重 複 利 用, 是 相 當 重 要 的 在 Java 程 式 裡, 為 了 讓 每 一 行 程 式 都 具 有 高 利 用 價 值, 而 採 用 了 類 別 繼 承 的 觀 念 來 實 現 此 一 精 神 並 且, 類 別 繼 承 能 夠 讓 程 式 更 利 於 管 理 和 閱 讀 Java 的 類 別 繼 承 可 以 分 為 一 般 類 別 的 繼 承 與 介 面 類 別 的 繼 承 由 於 尚 未 介 紹 介 面 類 別, 因 此 本 節 先 介 紹 一 般 類 別 的 繼 承
.. 單 一 繼 承 Java 的 一 般 類 別 繼 承 可 以 是 單 一 繼 承, 也 可 以 是 擴 展 出 來 的 多 層 繼 承 我 們 先 介 紹 單 一 繼 承 延 伸 學 習 : 多 重 繼 承 C++ 支 援 多 重 繼 承 ( 一 個 類 別 擁 有 多 個 父 類 別 稱 為 多 重 繼 承 ), 但 Java 不 直 接 支 援 多 重 繼 承, 而 類 似 的 機 制 則 必 須 透 過 介 面 來 完 成.. 單 一 繼 承 在 Java 的 單 一 繼 承 中, 我 們 通 常 稱 被 衍 生 的 類 別 為 父 類 別 (parent class) 或 基 底 類 別 (base class) 而 繼 承 衍 生 而 來 的 類 別 稱 之 為 子 類 別 (child class) 或 衍 生 類 別 (derived class), 父 類 別 和 子 類 別 有 其 先 後 和 相 似 的 關 係 在 Java 中, 宣 告 單 一 繼 承 的 子 類 別 定 義 語 法 如 下 : class 衍 生 ( 子 ) 類 別 名 稱 extends 基 底 ( 父 ) 類 別 名 稱 繼 承 自 ; 延 伸 自 子 類 別 實 作 區 語 法 說 明 : () 父 類 別 可 以 是 使 用 者 自 訂 的 類 別, 也 可 以 是 Java 提 供 的 類 別, 但 使 用 Java 提 供 的 類 別 時, 必 須 將 其 import 進 來.. 單 一 繼 承 () 宣 告 子 類 別 時, 必 須 指 定 父 類 別 的 名 稱 並 且 其 中 使 用 了 關 鍵 字 extends,extends 的 原 文 具 延 伸 之 意, 故 繼 承 之 後, 除 了 父 類 別 的 既 有 成 員 之 外, 子 類 別 還 可 以 重 新 定 義 或 新 增 更 多 的 成 員 () 子 類 別 除 了 繼 承 父 類 別, 也 可 以 另 外 再 定 義 一 些 屬 於 自 己 的 成 員 變 數 和 函 式 ( 只 要 記 錄 於 上 述 語 法 的 子 類 別 實 作 區 中 即 可 ), 因 此 父 子 類 別 之 間 的 關 係 如 圖 - 所 示 () 繼 承 自 父 類 別 的 成 員 其 封 裝 等 級 同 父 類 別 原 本 之 封 裝 等 級 ( 含 package, public, protected ) 但 private 等 級 無 法 由 子 類 別 直 接 取 用, 必 須 透 過 父 類 別 其 他 等 級 的 成 員 取 用.. 單 一 繼 承 () 如 果 有 某 些 成 員 不 希 望 公 開 給 外 部 程 式 取 用, 但 希 望 繼 承 者 仍 可 使 用, 應 該 宣 告 為 protected 等 級, 但 仍 需 搭 配 不 同 package 來 限 制 () 建 構 子 無 法 被 繼 承 透 過 繼 承 機 制, 當 我 們 需 要 重 複 使 用 某 個 類 別 裡 的 一 些 成 員 時, 我 們 不 需 要 重 複 撰 寫 類 似 的 程 式 碼, 我 們 只 需 要 衍 生 出 一 個 新 的 子 類 別, 取 得 其 基 本 功 能 和 成 員, 再 針 對 需 求 加 以 新 增 或 修 改 即 可 這 也 就 是 重 複 使 用 程 式 碼 的 精 神 所 在 圖 - 父 子 類 別 之 間 的 關 係
.. 單 一 繼 承.. 單 一 繼 承 觀 念 範 例 - : 單 一 繼 承 語 法 的 基 本 練 習 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java) /* 檔 名 :ch_0.java 功 能 : 單 一 繼 承 */ package myjava.ch0; import java.io.console; // 載 入 Console 類 別,JDK 新 增 功 能 0 public class ch_0 // 主 類 別 CA obja = new CA(); CB objb = new CB();; //objb 是 子 類 別 物 件 System.out.println(" 輸 入 類 別 CA 的 obja 物 件 資 料 "); obja.inputx(); obja.inputy(); obja.inputz(); System.out.print(" 類 別 CA 的 obja 物 件 :"); obja.show(); System.out.println("-------------------------"); System.out.println(" 輸 入 類 別 CB 的 objb 物 件 資 料 "); objb.inputx(); 不 同 package 的 外 部 程 式 無 法 存 取 objb.inputy(); protected 等 級 資 料, 但 ch_0 目 前 objb.inputz(); 位 於 同 一 個 package 所 以 可 以 存 取 vary objb.varx++; //objb.vary++; objb.addone(); System.out.print(" 類 別 B 的 objb 物 件 :"); objb.show(); 0 0 0 class CA Console console = System.console(); public int varx; protected int vary; vary 被 宣 告 為 保 護 (protected) 等 級 private int varz; public void inputx() System.out.print("varX:"); varx=integer.parseint(console.readline()); public void inputy() System.out.print("varY:"); vary=integer.parseint(console.readline()); public void inputz() System.out.print("varZ:"); varz=integer.parseint(console.readline()); public void show() System.out.println("varX=" + varx + " vary=" + vary + " varz=" + varz);.. 單 一 繼 承 0 class CB extends CA public int varw; // 新 增 的 成 員 變 數 public void addone() // 新 增 的 成 員 函 式 varx++; vary++; //varz++; 執 行 結 果 : 類 別 CB 繼 承 自 類 別 CA 無 法 直 接 存 取 父 類 別 private 等 級 資 料, 必 須 透 過 同 樣 是 由 父 類 別 繼 承 而 來 的 method 進 行 存 取 輸 入 類 別 CA 的 obja 物 件 資 料 varx: vary: varz: 類 別 CA 的 obja 物 件 :varx= vary= varz= ------------------------- 輸 入 類 別 CB 的 objb 物 件 資 料 varx: vary: varz: 類 別 B 的 objb 物 件 :varx= vary= varz=
.. 單 一 繼 承 () 第 行 是 透 過 外 部 程 式 存 取 objb 的 vary 成 員 變 數, 若 外 部 程 式 與 宣 告 protected 成 員 的 CA 類 別 位 於 不 同 的 package, 則 無 法 存 取 不 過 此 時 是 可 以 存 取 的 ( ch_0 類 別 目 前 與 CA 類 別 位 於 同 一 個 package) 您 若 將 第 行 註 解 取 消, 會 發 現 範 例 仍 舊 是 可 以 編 譯 的, 我 們 將 於 第 章 講 解 類 別 庫 時, 重 新 探 討 這 個 案 例 ()varz 在 父 類 別 中, 被 宣 告 為 private 等 級, 所 以 在 被 繼 承 後 無 法 被 直 接 存 取, 因 此 第 行 無 法 透 過 子 類 別 的 成 員 函 式 存 取 varz 成 員 變 數 ( 註 解 不 可 取 消 ) 但 varz 仍 舊 可 以 被 繼 承 而 來 的 父 類 別 inputz show 等 method 存 取.. 單 一 繼 承 父 子 類 別 的 建 構 子 執 行 順 序 在 建 立 子 類 別 物 件 時, 會 先 執 行 父 類 別 的 建 構 子, 然 後 才 執 行 子 類 別 的 建 構 子 當 您 未 建 立 建 構 子 時, 將 會 執 行 預 設 建 構 子 通 常, 我 們 會 將 父 類 別 成 員 的 初 始 化 放 在 父 類 別 建 構 子 中 完 成, 因 為 建 立 子 類 別 物 件 時, 會 先 自 動 執 行 父 類 別 建 構 子.. 單 一 繼 承.. 單 一 繼 承 觀 念 範 例 - : 父 子 類 別 的 建 構 子 執 行 順 序 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java) /* 檔 名 :ch_0.java 功 能 : 繼 承 的 建 構 子 執 行 順 序 */ package myjava.ch0; public class ch_0 // 主 類 別 CB objb = new CB(); //objb 是 子 類 別 物 件 objb.show(); 產 生 子 類 別 物 件 實 體, 會 先 執 行 父 類 別 的 建 構 子, 然 後 才 執 行 子 類 別 的 建 構 子 0 class CA protected int varx; public CA() System.out.println(" 父 類 別 建 構 子 執 行 中..."); varx=; 初 始 化 父 類 別 的 成 員 變 數 class CB extends CA // 類 別 CB 繼 承 自 類 別 CA public CB() System.out.println(" 子 類 別 建 構 子 執 行 中..."); public void show() System.out.println("varX=" + varx); 父 類 別 建 構 子 子 類 別 建 構 子
.. 單 一 繼 承 執 行 結 果 : 範 例 說 明 : 父 類 別 建 構 子 執 行 中... 子 類 別 建 構 子 執 行 中... varx= 先 執 行 的 是 父 類 別 的 建 構 子 後 執 行 的 是 子 類 別 的 建 構 子 由 執 行 結 果 中, 可 以 看 出 在 建 立 子 類 別 物 件 時, 會 先 執 行 父 類 別 的 建 構 子, 然 後 才 執 行 子 類 別 的 建 構 子, 同 時, 我 們 在 父 類 別 內 對 成 員 變 數 作 了 初 始 化 動 作, 所 以 在 子 類 別 物 件 中 的 varx 也 是.. super 關 鍵 字 子 類 別 在 繼 承 父 類 別 時, 子 類 別 的 新 成 員 可 以 和 父 類 別 成 員 同 名 如 果 是 method 同 名 的 話, 則 稱 為 覆 寫 (override), 我 們 將 會 在 後 面 介 紹 如 果 是 變 數 同 名, 則 不 會 將 父 類 別 的 變 數 覆 蓋, 而 是 將 繼 承 而 來 的 父 類 別 之 同 名 成 員 變 數 隱 藏 (hide), 所 以 是 兩 者 獨 立 的 兩 個 變 數 要 取 用 子 類 別 的 同 名 變 數, 就 如 同 一 般 撰 寫 程 式 般 取 用 即 可 而 要 取 用 父 類 別 物 件 的 同 名 變 數, 則 可 透 過 super 關 鍵 字 來 達 成.. super 關 鍵 字.. super 關 鍵 字 在 Java 中,this 代 表 的 是 參 考 物 件 本 身,super 代 表 的 則 是 參 考 父 類 別 物 件 本 身 如 果 要 讀 取 父 類 別 某 個 成 員, 可 以 使 用 super. 父 類 別 成 員 語 法 來 完 成, 但 不 可 以 使 用 這 種 方 式 在 子 類 別 中 讀 取 父 類 別 的 private 成 員 如 果 想 要 在 子 類 別 的 建 構 子 中 執 行 父 類 別 的 建 構 子, 只 需 要 使 用 super( 引 數 串 ) 來 完 成 即 可, 不 過 它 必 須 放 在 子 類 別 建 構 子 的 第 一 行 才 行 觀 念 範 例 - : 子 類 別 變 數 與 父 類 別 變 數 名 稱 相 同 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java) /* 檔 名 :ch_0.java 功 能 :super 的 練 習 */ package myjava.ch0; public class ch_0 // 主 類 別 CB objb = new CB(); //objb 是 子 類 別 物 件 objb.show(); 執 行 結 果 子 類 別 varx=0 父 類 別 varx= class CA 父 類 別 的 成 員 public int varx; public CA() System.out.println(" 父 類 別 無 參 數 建 構 子 執 行 中..."); public CA(int i) varx=i;
.. super 關 鍵 字.. super 關 鍵 字 0 0 class CB extends CA // 子 類 別 CB 繼 承 自 類 別 CA public int varx; // 新 增 的 成 員 變 數, 與 父 類 別 成 員 同 名 public CB() 呼 叫 父 類 別 建 構 子 public public CB(int i) CA(int i), 必 須 放 在 第 一 行 super(i); varx=0; 存 取 子 類 別 的 成 員 public void show() // 新 增 的 成 員 函 式 存 取 父 類 別 的 成 員 super.varx++; System.out.println(" 子 類 別 varx=" + varx); System.out.println(" 父 類 別 varx=" + super.varx); 範 例 說 明 : ()CB 繼 承 CA, 並 且 新 增 一 個 同 名 的 變 數 varx 第 0 行 取 用 的 是 子 類 別 的 變 數 varx, 第 行 取 用 的 是 父 類 別 的 varx 小 試 身 手 () 第 行 是 呼 叫 第 ~ 行 的 父 類 別 建 構 子 由 執 行 結 果 中, 可 以 發 現, 無 參 數 的 父 類 別 建 構 子 並 不 會 被 執 行, 因 為 編 譯 器 發 現 您 在 子 類 別 的 建 構 子 中, 已 經 呼 叫 父 類 別 的 建 構 子 如 果 將 第 行 刪 除, 則 第 ~ 行 的 父 類 別 建 構 子 會 自 動 被 執 行 () 如 果 您 同 時 將 第 行 刪 除, 也 將 第 ~ 行 的 父 類 別 建 構 子 刪 除, 則 編 譯 時 會 發 生 錯 誤, 因 為 編 譯 器 想 要 執 行 一 個 無 參 數 的 建 構 子, 卻 發 現 找 不 到 還 記 得 上 一 章 曾 經 提 及, 一 但 我 們 建 立 了 任 何 一 個 建 構 子, 則 預 設 的 建 構 子 將 不 會 出 現 嗎! 請 將 範 例 的 第 行 第 ~ 行 都 刪 除, 然 後 重 新 編 譯, 看 看 會 產 生 什 麼 錯 誤 訊 息.. 改 寫 (Override) 在 範 例 - 中, 成 員 變 數 在 被 繼 承 後 仍 舊 可 以 另 行 宣 告 一 個 專 屬 於 子 類 別 的 同 名 成 員 變 數 那 麼 如 果 在 子 類 別 中 宣 告 一 個 與 父 類 別 同 署 名 的 method, 情 況 又 會 是 如 何 呢? 答 案 是 發 生 改 寫 (override) 現 象 當 子 類 別 欲 改 寫 父 類 別 的 method 時, 有 以 下 幾 點 必 須 注 意 : () 署 名 雖 然 不 包 含 方 法 的 封 裝 等 級, 但 在 改 寫 時, 只 能 擴 大 封 裝 等 級, 而 不 能 縮 小 封 裝 等 級 例 如 protected 可 在 改 寫 時, 改 為 public, 但 相 反 則 否 () 改 寫 的 回 傳 值 型 態 只 能 是 相 同 或 原 本 資 料 型 態 的 子 類 別 型 態 ( 在 JDK.0 之 前, 則 完 全 不 允 許 改 變 回 傳 值 型 態 ) () 父 類 別 的 static method 無 法 被 改 寫 但 我 們 確 實 可 以 在 子 類 別 中 定 義 一 個 新 的 同 名 static method, 但 那 並 非 改 寫, 而 是 兩 個 不 相 關 的 method.. 改 寫 (Override) 改 寫 (override) 與 多 載 (overload) 改 寫 (override) 與 之 前 介 紹 的 多 載 (overload) 是 完 全 不 同 的 兩 種 機 制, 兩 者 之 分 別 如 下 : () 多 載 的 methods 必 須 位 於 同 一 個 類 別 視 野 而 改 寫 的 兩 個 成 員 則 分 處 於 不 同 的 類 別 視 野, 一 個 位 於 父 類 別, 另 一 個 位 於 子 類 別 () 多 載 必 須 是 同 名 但 不 同 署 名 而 改 寫 則 必 須 是 同 署 名 例 如, 如 果 類 別 A 有 一 個 func(), 而 類 別 B 繼 承 自 類 別 A, 同 時 又 定 義 了 一 個 func(int X), 則 兩 者 並 沒 有 多 載 或 改 寫 現 象, 但 這 還 是 允 許 的, 因 為 編 譯 器 可 以 輕 鬆 地 辨 別 所 呼 叫 的 對 象 延 伸 學 習 :abstract method abstract method 是 一 個 只 有 宣 告 沒 有 定 義 的 method 事 實 上, 改 寫 最 常 發 生 在 abstract method, 我 們 將 於. 節 說 明
.. 改 寫 (Override).. 改 寫 (Override) 在 改 寫 的 狀 況 下, 我 們 必 須 告 知 編 譯 器, 目 前 要 呼 叫 的 是 子 類 別 物 件 的 同 名 method 還 是 父 類 別 物 件 的 同 名 method 若 是 呼 叫 子 類 別 物 件 的 同 名 method 則 只 要 直 接 呼 叫 即 可 若 是 呼 叫 父 類 別 物 件 的 同 名 method, 則 必 須 透 過 super 來 完 成 請 看 下 一 個 範 例 的 示 範 觀 念 範 例 - : 改 寫 (Override) 的 練 習 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java) /* 檔 名 :ch_0.java 功 能 : 改 寫 (override) 的 練 習 */ package myjava.ch0; public class ch_0 CB objb = new CB(); //objb 是 子 類 別 物 件 objb.show(); objb.show(); objb.show(.0); class CA public void show() System.out.println(" 目 前 執 行 父 類 別 的 show()"); 執 行 結 果 目 前 執 行 子 類 別 的 show() 目 前 執 行 子 類 別 的 show() 目 前 執 行 子 類 別 的 show(double) 目 前 執 行 父 類 別 的 show().. 改 寫 (Override).. 改 寫 (Override) 0 0 class CB extends CA // 類 別 CB 繼 承 自 類 別 CA 子 類 別 的 show() override 父 類 別 的 public void show() show() System.out.println(" 目 前 執 行 子 類 別 的 show()"); public void show(int x) System.out.println(" 目 前 執 行 子 類 別 的 show(" + x +")"); public void show(double x) System.out.println(" 目 前 執 行 子 類 別 的 show(double)"); super.show(); 呼 叫 父 類 別 的 method 小 試 身 手 () 第 行 為 執 行 父 類 別 物 件 的 show() 函 式, 故 由 此 可 以 看 出 改 寫 並 非 將 原 本 的 函 式 覆 蓋, 可 以 將 其 視 為 隱 藏 的 現 象 () 您 可 以 將 第 行 的 public 改 寫 為 protected, 程 式 仍 是 合 法 的, 因 為 改 寫 時, 允 許 擴 大 封 裝 等 級 請 將 範 例 的 第 行 改 為 protected void show(), 然 後 重 新 編 譯, 看 看 是 否 可 通 過 編 譯? 範 例 說 明 : () 第 ~ 行 的 show() 改 寫 了 第 ~ 行 的 show() 成 員 函 式 () 第 行 與 第 行 的 methods 為 改 寫 (Override) 的 關 係 第 行 第 行 第 行 的 methods 為 多 載 (Overload) 的 關 係 第 行 與 第 行 的 methods 既 非 多 載 也 非 改 寫 的 關 係
.. @Override 註 記 註 記 (annotation) 也 可 以 算 是 一 種 註 解, 但 為 何 本 書 不 將 之 納 為 第 二 章 的 註 解 種 類 主 要 是 因 為, 註 記 (annotation) 不 只 是 給 人 看 的 註 解, 也 是 給 編 譯 器 看 的 註 解 註 記 是 以 @ 為 開 頭 常 見 的 有 @Override, @Deprecated, @SuppressWarnings,@interface, @Document 與 @Deplicate... 等 等, 甚 至 還 允 許 使 用 者 自 行 定 義 註 記 它 是 Java SE 才 開 始 支 援 的 機 制, 最 主 要 的 目 的 是 幫 助 程 式 的 開 發 例 如 避 免 因 撰 寫 程 式 時 的 不 注 意 而 犯 下 合 乎 語 法, 但 不 符 設 計 者 原 意 的 錯 誤 在 本 小 節 中, 我 們 將 介 紹 @Override 註 記.. @Override 註 記 假 設 我 們 有 一 個 A 父 類 別, 當 中 有 一 個 ridebike() 方 法 而 另 有 一 個 子 類 別 B 繼 承 了 A 類 別 並 且 想 要 改 寫 ridebike() 方 法 但 是 由 於 A 父 類 別 放 置 在 其 他 檔 案 中, 因 此 設 計 師 以 為 該 方 法 的 名 稱 是 ridebicycle() 方 法, 故 而 在 B 類 別 中 定 義 了 一 個 ridebicycle() 方 法 想 要 改 寫 ridebike() 方 法 結 果 是, 編 譯 器 不 會 幫 設 計 者 找 出 這 個 錯 誤 因 為, 對 於 編 譯 器 而 言, 類 別 B 將 會 有 兩 個 不 同 名 稱 的 方 法 一 個 是 繼 承 而 來 未 改 寫 的 ridebike() 方 法 另 一 個 是 新 增 的 ridebicycle() 方 法 除 非 設 計 者 在 B 類 別 中 呼 叫 了 super.ridebicycle() 方 法, 否 則 編 譯 器 不 會 顯 示 錯 誤, 但 執 行 結 果 可 能 與 設 計 者 想 要 的 結 果 不 同 0.. @Override 註 記 更 常 見 的 例 子 出 現 在 參 數 數 量 或 型 態 的 不 同 假 設 類 別 A 有 一 個 用 來 計 算 面 積 的 calarea(int len, int width) 方 法 而 類 別 B 繼 承 類 別 A 之 後 欲 改 寫 計 算 面 積 的 calarea 方 法, 因 此 定 義 了 一 個 calarea(double len, double width) 方 法 則 編 譯 器 還 是 會 將 之 視 為 新 增 的 方 法 而 非 改 寫, 這 也 可 能 與 設 計 者 的 原 意 並 不 相 同 有 鑑 於 編 譯 器 只 能 以 完 整 的 署 名 來 判 斷 是 否 為 改 寫, 因 此,Java 提 供 了 一 項 機 制, 協 調 設 計 者 與 編 譯 器 的 認 知 亦 即 在 撰 寫 方 法 前, 使 用 @Override 來 做 註 記, 代 表 接 下 來 定 義 的 方 法 是 一 個 改 寫 方 法, 而 非 子 類 別 的 新 增 方 法 這 個 註 解 雖 然 主 要 是 寫 給 編 譯 器 看 的, 但 實 際 上 也 可 以 使 得 日 後 維 護 的 人 員 很 容 易 辨 認 為 何 會 出 現 這 個 method.. @Override 註 記 因 此, @Override 註 記 在 許 多 使 用 由 他 人 提 供 類 別 庫 的 場 合 中, 非 常 具 有 實 用 性 例 如 開 發 Android 應 用 程 式 時, 就 會 常 常 見 到 原 始 碼 中 出 現 @Override 這 個 關 鍵 字 觀 念 範 例 - : 將 範 例 - 改 編, 利 用 @Override 來 標 記 要 改 寫 的 方 法 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java)
.. @Override 註 記 執 行 結 果 : /* 檔 名 :ch_0.java 功 能 :@Override 的 練 習 */ package myjava.ch0; public class ch_0 // 主 類 別 CB objb = new CB(); //objb 是 子 類 別 物 件 objb.show(); objb.show(); objb.show(.0); class CA public void show() System.out.println(" 目 前 執 行 父 類 別 的 show()");.. @Override 註 記 0 0 告 知 編 譯 器, 這 個 method 是 要 改 寫 父 類 別 的 show() override 父 類 class CB extends CA 別 的 show() @Override public void show() System.out.println(" 目 前 執 行 子 類 別 的 show()"); public void show(int x) System.out.println(" 目 前 執 行 子 類 別 的 show(" + x +")"); public void show(double x) System.out.println(" 目 前 執 行 子 類 別 的 show(double)"); super.show(); 執 行 結 果 : ( 同 範 例 - 執 行 結 果 ) 範 例 說 明 : 第 行 加 入 了 @Override 註 記, 編 譯 器 就 可 以 知 道 第 ~ 行 的 show() 是 要 改 寫 父 類 別 的 show() 小 試 身 手 請 將 範 例 的 第 行 改 為 @Override public void show(int x), 然 後 重 新 編 譯, 看 看 是 否 可 通 過 編 譯? 並 解 釋 為 何 能 通 過 或 為 何 不 能 通 過 編 譯.. 繼 承 機 制 之 物 件 實 體 建 構 順 序.. 繼 承 機 制 之 物 件 實 體 建 構 順 序 由 之 前 所 介 紹 的 建 構 子 執 行 順 序, 我 們 可 以 將 單 一 繼 承 的 物 件 實 體 建 構 順 序 繪 製 如 下 圖 : 圖 - 子 類 別 物 件 實 體 產 生 過 程 在 前 一 章 我 們 介 紹 物 件 實 體 的 內 容 時, 曾 經 提 及, 對 於 非 static 的 成 員 變 數 而 言, 物 件 實 體 產 生 後, 將 有 一 塊 記 憶 體 存 放 專 屬 於 該 物 件 實 體 的 成 員 變 數, 而 對 於 非 static method 而 言, 則 會 存 放 method 的 程 式 進 入 點 如 果 類 別 在 定 義 時, 採 用 的 是 繼 承 機 制, 則 產 生 類 別 的 物 件 實 體 時, 如 圖 - 所 示, 物 件 實 體 內 會 包 含 父 類 別 的 物 件 實 體, 這 也 是 為 何 父 類 別 的 成 員 變 數 即 使 與 子 類 別 的 成 員 變 數 同 名, 也 不 會 被 覆 蓋 的 原 因 因 為 兩 者 在 物 件 實 體 產 生 後, 會 在 物 件 實 體 內 佔 據 不 同 的 記 憶 體 位 置 所 以 當 變 數 同 名 時, 仍 可 以 藉 由 super 存 取 到 其 中 的 父 類 別 物 件 實 體 內 的 變 數
.. 多 層 繼 承 多 層 繼 承 屬 於 垂 直 性 的 層 代 繼 承 例 如, 子 類 別 繼 承 父 類 別, 父 類 別 繼 承 祖 父 類 別 由 於 多 層 繼 承 的 機 制, 使 得 Java 在 開 發 大 型 程 式 時, 能 夠 更 有 效 率 並 且 更 容 易 管 理 前 面 所 介 紹 的 單 一 繼 承, 僅 討 論 父 類 別 與 子 類 別 的 兩 代 繼 承 關 係, 若 將 其 層 代 擴 充 到 三 代 以 上, 就 形 成 了 多 層 類 別 的 繼 承 在 多 層 繼 承 中, 類 別 的 繼 承 具 有 先 後 關 係, 所 有 下 層 的 類 別 都 具 有 最 底 層 基 底 類 別 的 功 能, 而 越 下 層 的 類 別 將 繼 承 越 多 的 成 員 ( 因 為 每 一 層 都 可 以 新 增 一 些 成 員 ), 如 下 圖 所 示.. 多 層 繼 承 圖 - 多 層 繼 承 示 意 圖.. 多 層 繼 承 當 進 行 多 層 繼 承 時, 越 下 層 的 物 件 實 體 將 會 越 變 越 大 因 為, 下 層 物 件 實 體 內 將 包 含 所 有 上 層 的 物 件 實 體 而 建 構 子 的 執 行 順 序, 也 是 由 最 上 層 的 建 構 子 開 始 執 行 事 實 上, 您 可 以 將 建 構 子 的 執 行 看 作 是 一 種 引 發 的 關 係 在 兩 層 繼 承 之 時, 子 類 別 的 建 構 子 會 先 引 發 父 類 別 的 建 構 子 ( 引 發 可 分 為 自 動 及 手 動, 手 動 時 super( 引 數 串 ) 呼 叫 必 須 放 在 第 一 行 ), 所 以 父 類 別 的 建 構 子 會 先 執 行, 然 後 才 執 行 子 類 別 的 建 構 子 ( 手 動 時, 則 執 行 子 類 別 建 構 子 第 行 以 後 的 敘 述 ).. 多 層 繼 承 在 三 層 繼 承 時, 則 子 類 別 的 建 構 子 會 先 引 發 父 類 別 的 建 構 子, 而 父 類 別 的 建 構 子 則 會 引 發 祖 父 類 別 的 建 構 子, 所 以 祖 父 類 別 的 建 構 子 會 先 被 執 行, 然 後 是 父 類 別 的 建 構 子, 最 後 是 子 類 別 的 建 構 子 我 們 透 過 一 個 範 例 來 說 明 多 層 類 別 的 建 構 子 執 行 順 序 觀 念 範 例 - : 多 層 繼 承 的 建 構 子 執 行 順 序 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java) 0
.. 多 層 繼 承 /* 檔 名 :ch_0.java 功 能 : 多 層 繼 承 之 建 構 子 呼 叫 */ package myjava.ch0; public class ch_0 // 主 類 別 CC objc = new CC(); CC objc = new CC(); CC objc = new CC(,); objc.show(); objc.show(); objc.show();.. 多 層 繼 承 0 0 class CA protected int vara; public CA() vara=; public CA(int i) vara=i; class CB extends CA // 類 別 CB 繼 承 自 類 別 CA protected int varb; public CB() varb=; public CB(int i) super(i); varb=i; class CC extends CB // 類 別 CC 繼 承 自 類 別 CB protected int varc; public CC() varc=; public CC(int i)varc=i; public CC(int i,int j) super(i*j); varc=i*j;.. 多 層 繼 承.. 多 層 繼 承 0 public void show() System.out.print("varA=" + vara + "\t"); System.out.print("varB=" + varb + "\t"); System.out.println("varC=" +varc); 執 行 結 果 : 範 例 說 明 : vara= varb= varc= vara= varb= varc= vara= varb= varc= CC 類 別 繼 承 CB 類 別,CB 類 別 繼 承 CA 類 別 本 範 例 一 共 有 三 個 CC 類 別 的 物 件,objC,objC,objC, 當 物 件 建 立 時, 其 建 構 子 的 呼 叫 順 序 如 下 圖, 如 果 底 層 的 建 構 子 內, 在 第 一 行 未 註 明 super 執 行 某 個 特 定 的 上 層 建 構 子, 則 會 自 動 先 執 行 上 層 無 參 數 的 建 構 子
.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 類 別 型 態 的 物 件 參 考 可 以 指 向 相 容 類 別 的 物 件 實 體 此 處 所 謂 相 容 (compatible) 類 別 代 表 的 是 其 衍 生 類 別, 例 如 子 類 別 或 孫 類 別 等 等 所 以 我 們 可 以 宣 告 一 個 物 件 變 數, 宣 告 型 態 時 採 用 父 類 別 型 態, 但 卻 將 它 指 向 子 類 別 物 件 實 體 例 如 下 列 範 例 : class CA... class CB extends CA... CA obj = new CB(); 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 當 父 類 別 型 態 的 物 件 變 數 指 向 子 類 別 的 物 件 實 體 後, 我 們 可 以 透 過 該 變 數 執 行 子 類 別 中 改 寫 (override) 的 method 或 其 他 未 改 寫 的 繼 承 method, 但 不 能 執 行 子 類 別 的 新 增 method 觀 念 範 例 - : 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java).. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 /* 檔 名 :ch_0.java 功 能 : 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 */ package myjava.ch0; public class ch_0 // 主 類 別 CA obj = new CB(); 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 obj.show(); // 可 執 行 子 類 別 改 寫 的 函 式 obj.show(); // 可 執 行 繼 承 的 函 式 //obj.show(); 不 能 執 行 子 類 別 新 增 的 函 式 class CA protected int vara; public void show() System.out.println(" 父 類 別 show() 執 行 中 "); 0 0 public void show() System.out.println(" 父 類 別 show() 執 行 中 "); class CB extends CA // 子 類 別 CB 繼 承 自 類 別 CA protected int varb; @Override public void show() System.out.println(" 子 類 別 改 寫 的 show() 執 行 中 "); public void show() System.out.println(" 子 類 別 新 增 的 show() 執 行 中 "); 執 行 結 果 : 子 類 別 改 寫 的 show() 執 行 中 父 類 別 show() 執 行 中
.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 範 例 說 明 : () 父 類 別 CA 定 義 了 show() 與 show() 兩 個 methods 子 類 別 CB 定 義 了 show() 與 show() 兩 個 methods, 由 於 CB 繼 承 了 CA, 因 此 show() 為 改 寫 的 method () 第 行, 宣 告 變 數 型 態 為 父 類 別, 但 new 產 生 實 體 時 為 子 類 別, 因 此, 父 類 別 變 數 obj 將 指 向 子 類 別 物 件 實 體 () 第 行,obj 可 以 執 行 子 類 別 改 寫 的 method 第 行,obj 可 以 執 行 子 類 別 繼 承 自 父 類 別 的 method 第 行,obj 不 能 執 行 子 類 別 新 增 的 method 實 用 範 例 - : 假 設 我 們 有 一 個 圖 形 類 別, 當 中 包 含 area 變 數 以 作 為 存 放 圖 形 面 積 之 用 由 於 計 算 面 積 按 照 圖 形 的 種 類 而 有 各 種 不 同 的 公 式, 故 我 們 將 計 算 面 積 的 函 式 保 留 交 由 繼 承 的 子 類 別 改 寫 來 完 成 請 建 立 一 個 圖 形 類 別 的 物 件 陣 列, 計 算 面 積 後, 將 陣 列 依 照 面 積 排 序, 最 後 輸 出 陣 列 內 各 物 件 的 面 積 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java) 0.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 /* 檔 名 :ch_0.java 功 能 : 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 的 應 用 */ package myjava.ch0; public class ch_0 // 主 類 別 CShape objarr[] = new CShape[]; objarr[0] = new CRect(.0,.0); objarr[] = new CRect(.0,.0); objarr[] = new CCircle(.0); objarr[] = new CCircle(.0); for(int i=0;i<objarr.length;i++) objarr[i].computearea(); System.out.println(" 物 件 的 面 積 如 下 "); CShape.show(objArr); // 顯 示 面 積 CShape.sortByArea(objArr); // 進 行 排 序 System.out.println(" 物 件 依 面 積 排 序 後 如 下 "); CShape.show(objArr); // 顯 示 面 積 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 執 行 子 類 別 改 寫 的 計 算 面 積 公 式 0 0 class CShape protected double area; public static void show(cshape objarr[]) for(int i=0;i<objarr.length;i++) System.out.print(objArr[i].area + "\t"); System.out.println(); public static void sortbyarea(cshape objarr[]) // 排 序 int k,times; CShape temp; k=objarr.length-; while(k!=0) times=0; for(int i=0;i<=k-;i++)
.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體.. 父 類 別 型 態 變 數 參 考 子 類 別 物 件 實 體 0 0 0 if(objarr[i].area > objarr[i+].area) temp=objarr[i]; objarr[i]=objarr[i+]; objarr[i+]=temp; times=i; k=times; public void computearea() class CRect extends CShape // 類 別 CRect 繼 承 自 類 別 CShape protected double length,width; public CRect(double i,double j) length=i; width=j; @Override public void computearea() area=length*width; 0 class CCircle extends CShape // 類 別 CCircle 繼 承 自 類 別 CShape protected double radius; protected final double pi=.; public CCircle(double i) radius=i; @Override public void computearea() area=radius*radius*pi; 執 行 結 果 : 物 件 的 面 積 如 下 0.0.0..0 物 件 依 面 積 排 序 後 如 下..0.0 0.0. final 修 飾 字 的 用 途 final 是 一 個 修 飾 字, 它 可 以 出 現 在 下 列 三 個 位 置, 在 不 同 位 置 有 不 同 的 意 義 : () 宣 告 變 數 時 : 代 表 該 變 數 為 只 能 設 定 一 次 然 後 就 不 可 改 變 數 值 ( 若 為 物 件 變 數, 則 參 考 只 能 指 向 第 一 次 指 向 的 物 件 實 體 ) 使 用 於 區 域 變 數 時, 只 能 設 定 一 次 然 後 就 不 可 改 變 數 值 使 用 於 函 式 的 參 數 時, 則 引 數 傳 遞 後, 接 收 端 函 式 內 不 可 改 變 其 參 數 值 使 用 於 定 義 成 員 變 數 時, 除 了 第 一 次 設 定 之 外, 包 含 繼 承 後 都 不 能 再 改 變 其 值. final 修 飾 字 的 用 途 () 宣 告 於 類 別 的 method 時 : 代 表 繼 承 後, 不 可 被 改 寫 (override) () 宣 告 於 類 別 時 : 代 表 該 類 別 不 可 被 繼 承 ( 終 止 繼 承 ) 例 如 Java 的 String 內 建 類 別 就 被 宣 告 為 final, 因 此 我 們 無 法 繼 承 String 類 別 ( 所 幸,String 類 別 已 經 非 常 完 整, 應 該 提 供 的 字 串 相 關 methods 功 能 大 多 已 提 供 了 )
. final 修 飾 字 的 用 途 範 例 : 使 用 final 宣 告 變 數 class CA var 只 能 設 定 一 次, 以 後 不 可 以 再 改 變 public final int var; // 宣 告 於 成 員 變 數 public void func(final int i) // 宣 告 於 參 數 i 不 可 以 再 被 設 定 final int j=; // 宣 告 於 區 域 變 數 j 不 可 以 再 被 設 定. final 修 飾 字 的 用 途 範 例 : 使 用 final 宣 告 類 別 的 method class CA public final void show() show() 不 可 以 被 改 寫 範 例 : 使 用 final 宣 告 類 別 final class CA CA 類 別 不 可 以 被 繼 承. final 修 飾 字 的 用 途. final 修 飾 字 的 用 途 觀 念 範 例 - :final 在 不 同 位 置 的 修 飾 用 途 範 例 -:ch_0.java( 隨 書 光 碟 myjava\ch0\ch_0.java) /* 檔 名 :ch_0.java 功 能 :final 在 不 同 位 置 的 修 飾 用 途 */ package myjava.ch0; public class ch_0 // 主 類 別 final String str = new String ("final 修 飾 字 的 示 範 "); //str = new String("..."); 錯 誤, 因 為 str 參 考 已 被 設 定 過, 不 System.out.println(str); 可 指 向 其 他 物 件 實 體 CB obj = new CB(); obj.add(); obj.show(); // 執 行 繼 承 自 父 類 別 的 show() 0 class CA public final int var; public int var; public CA() var=; var=; public void add() //var++; var++; 錯 誤, 因 為 var 已 經 在 建 構 子 內 設 定 過 一 次 public final void show() // 不 可 被 改 寫 的 函 式 System.out.println("var=" + var + "\tvar=" + var); 0
. final 修 飾 字 的 用 途. Object 類 別 0 0 class CB extends CA // 子 類 別 CB 繼 承 自 類 別 CA public void add() //var=var+; var=var+var; //public void show() final class CC // 類 別 不 可 被 繼 承 public int var; //class CD extends CC 錯 誤, 因 為 var 已 經 在 父 類 別 建 構 子 內 設 定 過 一 次 錯 誤, 因 為 show 不 可 被 改 寫 錯 誤, 因 為 CC 不 可 被 繼 承 Java 之 所 以 被 稱 為 純 物 件 導 向 程 式 語 言, 除 了 它 支 援 物 件 導 向 的 三 大 特 色 之 外, 還 有 兩 個 重 要 的 原 因 第 一 個 原 因 是 所 有 的 函 式 必 定 屬 於 某 一 個 類 別 ( C++ 由 於 支 援 C, 故 有 些 函 式 不 一 定 屬 於 某 一 個 類 別 ) 第 二 個 原 因 是 Java 的 所 有 類 別 都 有 父 類 別 執 行 結 果 : final 修 飾 字 的 示 範 var= var=. Object 類 別 嚴 格 來 說, 在 Java 中, 除 了 巢 狀 類 別 ( 後 面 章 節 介 紹 ) 及 Object 類 別 之 外, 所 有 的 類 別 都 有 父 類 別 或 許 您 會 覺 得 奇 怪, 由 使 用 者 定 義 的 類 別, 常 常 未 宣 告 繼 承 自 哪 一 個 類 別 ( 如 範 例 - 的 CA 類 別 ), 那 麼 誰 是 它 的 父 類 別 呢? 其 實, 當 編 譯 Java 程 式 時, 編 譯 器 若 發 現 某 個 類 別 沒 有 宣 告 繼 承 自 哪 一 個 類 別 的 話, 它 會 自 動 將 Object 類 別 當 作 該 類 別 的 父 類 別 故 所 有 的 類 別 都 是 Object 類 別 的 子 類 別 或 孫 類 別 或 更 多 層 繼 承 之 後 的 衍 生 類 別 故 範 例 - 的 類 別 繼 承 可 如 下 圖 所 示 :. Object 類 別 圖 - 所 有 類 別 都 繼 承 自 Object 類 別 ( 範 例 - 類 別 繼 承 圖 )
. Object 類 別 Object 類 別 的 完 整 名 稱 為 java.lang.object 類 別 事 實 上, 除 了 類 別 會 經 由 直 接 或 間 接 繼 承 自 Object 類 別 之 外, 連 陣 列 也 同 樣 繼 承 了 Object 類 別 Object 類 別 中 沒 有 final method, 故 所 有 的 類 別 都 擁 有 Object 類 別 的 成 員, 並 且 可 以 改 寫, 下 表 是 Object 類 別 的 methods:. Object 類 別 函 式 宣 告 回 傳 值 說 明 說 明 boolean equals(object obj) 回 傳 布 林 值, 用 以 判 定 該 物 件 參 考 是 否 與 obj 參 考 同 一 個 物 件 實 體 見 後 面 說 明 Class<?> getclass() 回 傳 一 個 泛 型 類 別, 可 使 用 Class 類 別 的 物 件 變 數 接 收 回 傳 值 見 後 面 說 明 String tostring() 回 傳 字 串 物 件 參 考 見 後 面 說 明 protected Object clone() Object 代 表 一 個 物 件 變 數 複 製 物 件, 但 須 先 實 作 Cloneable 介 面 int hashcode() 回 傳 整 數, 代 表 hashcode 須 了 解 資 料 結 構 之 雜 湊 表 protected void finalize() 無 回 傳 值 垃 圾 回 收 使 用 void notify() 無 回 傳 值 多 執 行 緒 使 用 void notifyall() 無 回 傳 值 多 執 行 緒 使 用 void wait() void wait(long timeout) void wait(long timeout, int nanos) 無 回 傳 值 多 執 行 緒 使 用 表 - Object 的 methods. Object 類 別. Object 類 別 由 於 讀 者 尚 未 建 立 介 面 記 憶 體 垃 圾 回 收 機 制 與 多 執 行 緒 觀 念, 故 我 們 僅 介 紹 以 下 三 種 methods 的 使 用 方 法 : equals (Object obj) 物 件 相 等 判 斷 在 範 例 - 中, 我 們 曾 介 紹 如 何 判 定 兩 個 物 件 是 否 相 等, 事 實 上, 除 了 使 用 雙 等 號 來 判 斷 之 外, 也 可 以 用 equals() 來 判 斷 如 果 執 行 該 方 法 的 物 件 變 數 與 引 數 的 物 件 變 數 參 考 了 同 一 個 物 件 實 體, 則 回 傳 true, 否 則 回 傳 false, 請 見 下 列 範 例 - 觀 念 範 例 - : Object 類 別 的 equals() 的 練 習 範 例 -:ch_.java( 隨 書 光 碟 myjava\ch0\ch_.java) /* 檔 名 :ch_.java 功 能 : 物 件 的 比 較 */ package myjava.ch0; public class ch_ // 主 類 別 CMyClass X = new CMyClass(); CMyClass Y = new CMyClass(); CMyClass Z = X; 如 果 X 與 Y 參 考 同 一 個 物 件 實 體, 則 System.out.print(" 物 件 X 與 物 件 Y "); 回 傳 true if(x.equals(y)) System.out.println(" 兩 物 件 相 等 "); else System.out.println(" 兩 物 件 不 相 等 "); System.out.print(" 物 件 X 與 物 件 Z "); if(x.equals(z)) System.out.println(" 兩 物 件 相 等 "); else System.out.println(" 兩 物 件 不 相 等 ");
. Object 類 別. Object 類 別 0 class CMyClass private int Var; public CMyClass() public CMyClass(int i) Var=i; getclass() 取 得 物 件 所 屬 類 別 getclass 會 回 傳 物 件 所 屬 的 類 別, 它 回 傳 的 是 一 個 Class 型 態 的 泛 型, 我 們 可 以 用 一 個 內 建 Class 類 別 的 物 件 變 數 來 接 收, 並 且 該 物 件 變 數 也 可 以 直 接 由 println() 輸 出 內 容, 請 見 下 列 的 範 例 執 行 結 果 : 範 例 說 明 : 物 件 X 與 物 件 Y 兩 物 件 不 相 等 物 件 X 與 物 件 Z 兩 物 件 相 等 這 個 範 例 和 範 例 - 非 常 類 似, 只 不 過 我 們 在 判 定 物 件 參 考 是 否 相 等 時, 採 用 的 是 繼 承 而 來 的 equals() 函 式 觀 念 範 例 - : Object 類 別 的 getclass() 的 練 習 範 例 -:ch_.java( 隨 書 光 碟 myjava\ch0\ch_.java) 0. Object 類 別. Object 類 別 /* 檔 名 :ch_.java 功 能 :getclass() method */ package myjava.ch0; public class ch_ // 主 類 別 CMyClass X = new CMyClass(); Class Y; 回 傳 X 所 屬 類 別 Y=X.getClass(); System.out.println("X 屬 於 " + Y +" 的 物 件 "); String str = new String(".."); Y=str.getClass(); System.out.println("str 屬 於 " + Y +" 的 物 件 "); class CMyClass private int var; 執 行 結 果 : 範 例 說 明 : C:\>java myjava.ch0.ch_ X 屬 於 class myjava.ch0.cmyclass 的 物 件 str 屬 於 class java.lang.string 的 物 件 不 論 是 自 訂 類 別 或 Java 的 內 建 類 別, 都 可 以 使 用 getclass(), 因 為 它 是 繼 承 自 Object 類 別
. Object 類 別. Object 類 別 tostring() 轉 換 為 字 串 函 式 tostring() 可 以 將 物 件 內 容 轉 換 為 字 串, 不 過 這 個 字 串 通 常 沒 有 什 麼 用 途, 所 以 大 多 數 的 類 別 都 會 改 寫 tostring() 例 如 第 三 章 介 紹 的 Integer,Float 等 等 的 Java 內 建 類 別 都 改 寫 了 這 個 method, 使 得 能 夠 傳 回 所 需 要 的 字 串 請 見 下 列 的 範 例 觀 念 及 實 用 範 例 - :tostring() 的 改 寫 範 例 -:ch_.java( 隨 書 光 碟 myjava\ch0\ch_.java) /* 檔 名 :ch_.java 功 能 :tostring() 的 改 寫 */ package myjava.ch0; public class ch_ // 主 類 別 CRect X = new CRect(); CCircle Y = new CCircle(); String str = new String(); str=x.tostring(); System.out.println("CRect 類 別 物 件 執 行 tostring():\t" + str); str=y.tostring(); System.out.println("CCircle 類 別 物 件 執 行 tostring():\t"+ str);. Object 類 別 0 class CRect private int length,width; class CCircle private int radius; 改 寫 tostring() @Override public String tostring() return "CCircle 類 別 是 用 來 存 放 圓 形 "; 執 行 結 果 : C:\>java myjava.ch0.ch_ CRect 類 別 物 件 執 行 tostring(): myjava.ch0.crect@c0 CCircle 類 別 物 件 執 行 tostring(): CCircle 類 別 是 用 來 存 放 圓 形 範 例 說 明 : 本 範 例 的 CRect 沒 有 改 寫 tostring(), 所 以 印 出 的 資 訊 與 類 別 有 關, 而 CCircle 則 改 寫 了 tostring(), 使 得 該 method 有 些 用 途, 您 可 以 視 需 要 改 寫 tostring() 以 符 合 類 別 轉 字 串 的 用 途. 抽 象 類 別 物 件 導 向 的 重 點 之 一 為 多 型 (Polymorphism), 多 型 又 稱 同 名 異 式, 顧 名 思 義, 它 代 表 使 用 同 一 個 method 名 稱, 但 卻 可 以 有 不 同 的 method 內 容 除 了 我 們 先 前 所 介 紹 的 method 多 載 (Overload) 與 改 寫 (Override) 外, 在 本 節 中, 我 們 將 介 紹 Java 語 言 中, 另 一 種 與 method 多 功 能 化 有 關 的 技 巧, 稱 為 抽 象 方 法 (abstract method) 它 與 C++ 的 純 虛 擬 函 式 (pure virtual function) 功 能 類 似, 事 實 上, 抽 象 方 法 的 重 新 定 義 就 是 在 進 行 method 的 改 寫 (Override) 動 作
.. 抽 象 方 法 簡 介 回 顧 範 例 - 的 第 行, 我 們 定 義 了 一 個 computearea(), 但 method 內 容 是 空 的 所 以 如 果 繼 承 時 未 加 以 改 寫, 則 該 computearea() 根 本 就 是 多 餘 的 method 為 了 讓 method 定 義 更 有 意 義, 並 且 提 醒 繼 承 者 必 須 改 寫 該 函 式, 我 們 可 以 在 method 前 面 加 上 abstract 修 飾 字 如 果 我 們 將 method 定 義 的 語 法 區 分 為 method 宣 告 ( 第 一 行 ) 與 method 實 作 區 ( 其 餘 部 分 ), 則 使 用 abstract 修 飾 的 method 並 不 需 要 包 含 method 實 作 區, 並 且 必 須 在 宣 告 的 後 面 加 上 ; 分 號 結 尾.. 抽 象 方 法 簡 介 如 果 一 個 類 別 包 含 了 任 一 個 abstract method, 則 該 類 別 也 必 須 被 宣 告 為 abstract 類 別 加 上 abstract 修 飾 的 method 稱 為 抽 象 方 法 ( 抽 象 函 式 ; abstract method) 加 上 abstract 修 飾 的 類 別 則 稱 為 抽 象 類 別 (abstract class).. 抽 象 方 法 簡 介 其 語 法 格 式 如 下 : [ 封 裝 等 級 ] abstract class 類 別 名 稱 // 定 義 抽 象 類 別 若 包 含 abstract method, 則 類 別 必 須 宣 告 為 abstract class [ 封 裝 等 級 ] abstract 回 傳 值 型 態 method 名 稱 ( 參 數 串 ); // 宣 告 抽 象 方 法 : abstract method 沒 有 實 作 區 別 忘 了 結 尾 加 ; : [ 封 裝 等 級 ] [ 修 飾 字 ] 資 料 型 態 field 名 稱 ; // 宣 告 field : : [ 封 裝 等 級 ] [ 修 飾 字 ] 回 傳 值 型 態 method 名 稱 ( 參 數 串 ) //method 宣 告 區 method 的 內 容 //method 實 作 區 : :.. 抽 象 方 法 簡 介 語 法 說 明 () 包 含 抽 象 方 法 的 類 別 一 定 要 宣 告 為 抽 象 類 別 而 抽 象 類 別 無 法 使 用 new 產 生 物 件 實 體 () 抽 象 類 別 可 包 含 抽 象 method 與 一 般 method 抽 象 類 別 也 可 以 沒 有 抽 象 method, 但 即 使 如 此, 它 仍 無 法 使 用 new 產 生 物 件 實 體 () 由 於 抽 象 類 別 一 定 要 被 繼 承, 而 抽 象 方 法 一 定 要 被 改 寫, 故 其 封 裝 等 級 不 能 是 private () 抽 象 方 法 沒 有 method 實 作 區 () 抽 象 類 別 有 建 構 子 0
.. 抽 象 方 法 簡 介.. 抽 象 方 法 簡 介 () 繼 承 抽 象 類 別 同 樣 使 用 extends 關 鍵 字 來 達 成, 但 繼 承 抽 象 類 別 必 須 實 作 ( 改 寫 ) 抽 象 方 法, 如 果 有 任 何 一 個 抽 象 方 法 沒 有 被 實 作, 則 必 須 將 子 類 別 也 宣 告 為 抽 象 類 別, 以 便 強 迫 更 下 層 的 類 別 在 繼 承 它 之 後, 實 作 剩 餘 沒 有 被 實 作 的 抽 象 方 法 換 句 話 說, 只 有 當 所 有 的 成 員 method 都 被 實 作 之 後, 且 該 類 別 未 被 宣 告 為 abstract, 才 能 夠 使 用 new 產 生 物 件 實 體 觀 念 及 實 用 範 例 - : 以 範 例 - 的 CShape,CRect,CCircle 類 別 為 例, 將 computearea() 宣 告 為 抽 象 方 法 範 例 -:ch_.java( 隨 書 光 碟 myjava\ch0\ch_.java) /* 檔 名 :ch_.java 功 能 : 抽 象 類 別 與 抽 象 方 法 */ package myjava.ch0; public class ch_ // 主 類 別 //CShape obj = new CShape(); CRect obj = new CRect(.0,.0); CCircle obj = new CCircle(.0); obj.computearea(); // 計 算 面 積 obj.computearea(); // 計 算 面 積 System.out.print(" 矩 形 "); obj.show(); System.out.print(" 圓 形 "); obj.show(); 執 行 結 果 矩 形 area=.0 圓 形 area=. 錯 誤, 抽 象 類 別 不 能 產 生 物 件 實 體.. 抽 象 方 法 簡 介.. 抽 象 方 法 簡 介 0 0 包 含 了 抽 象 方 法, 所 以 必 須 宣 告 為 抽 象 類 別 abstract class CShape // 定 義 抽 象 類 別 protected double area; public void show() System.out.println("area=" + area); public abstract void computearea(); // 宣 告 抽 象 方 法 這 是 一 個 抽 象 方 法 class CRect extends CShape // 子 類 別 CRect 繼 承 自 類 別 CShape protected double length,width; public CRect(double i,double j) length=i; width=j; @Override public void computearea() area=length*width; 改 寫, 實 作 computearea() 0 class CCircle extends CShape // 類 別 CCircle 繼 承 自 類 別 CShape protected double radius; protected final double pi=.; public CCircle(double i) radius=i; @Override public void computearea() 改 寫, 實 作 computearea() area=radius*radius*pi; 範 例 說 明 : 本 範 例 的 CRect 與 CCircle 繼 承 了 抽 象 類 別 CShape, 並 實 作 了 抽 象 方 法 computearea() 故 這 兩 個 類 別 可 以 產 生 物 件 實 體
.. 抽 象 方 法 簡 介 觀 念 範 例 - : 抽 象 類 別 的 多 層 繼 承 範 例 -:ch_.java( 隨 書 光 碟 myjava\ch0\ch_.java) /* 檔 名 :ch_.java 功 能 : 抽 象 類 別 的 多 層 繼 承 */ package myjava.ch0; public class ch_ // 主 類 別 CMyRect obj = new CMyRect(.0,.0); obj.computearea(); // 計 算 面 積 obj.show(); 執 行 結 果 矩 形 area=.0 CMyRect 非 抽 象 類 別, 所 以 可 以 產 生 物 件 實 體 0 0. 抽 象 類 別 abstract class CShape // 定 義 抽 象 類 別 protected double area; public abstract void show(); // 宣 告 抽 象 方 法 public abstract void computearea(); // 宣 告 抽 象 方 法 子 類 別 CRect 繼 承 自 類 別 CShape, 但 未 完 全 實 作 全 部 的 抽 象 方 法, 故 仍 為 抽 象 類 別 abstract class CRect extends CShape // protected double length,width; public CRect(double i,double j) length=i; width=j; @Override public void computearea() // 改 寫, 實 作 computearea() area=length*width; class CMyRect extends CRect // 子 類 別 CMyRect 繼 承 自 類 別 CRect public CMyRect(double i,double j) 改 寫 尚 未 實 作 的 show() super(i,j); @Override public void show() // 改 寫, 實 作 show() 函 式 System.out.println(" 矩 形 area=" + area);.. 抽 象 方 法 簡 介 範 例 說 明 : 本 範 例 的 CRect 繼 承 了 抽 象 類 別 CShape, 但 只 實 作 了 抽 象 方 法 computearea(), 而 未 實 作 抽 象 方 法 show(), 故 CRect 仍 為 抽 象 類 別 而 CMyRect 繼 承 了 CRect, 並 且 實 作 了 抽 象 方 法 show(), 此 時 所 有 的 抽 象 方 法 都 已 經 實 作 了, 故 CMyRect 類 別 可 以 產 生 物 件 實 體.. 抽 象 類 別 型 態 變 數 雖 然 抽 象 類 別 無 法 建 立 物 件 實 體, 但 我 們 仍 可 以 宣 告 抽 象 類 別 型 態 的 變 數 而 這 樣 的 變 數 有 何 用 途 呢? 在 前 面 曾 經 提 及, 父 類 別 物 件 變 數 可 以 指 向 子 類 別 物 件 實 體 因 此, 抽 象 類 別 型 態 的 變 數 只 能 用 於 指 向 子 類 別 物 件 實 體 ( 意 即 雖 然 抽 象 類 別 本 身 不 能 使 用 new 產 生 物 件 實 體, 但 可 以 用 new 產 生 指 向 子 類 別 物 件 ) 請 看 下 面 的 範 例 實 用 範 例 - : 改 寫 範 例 -, 將 CShape 宣 告 為 抽 象 類 別, 其 中 computearea() 為 抽 象 方 法 範 例 -:ch_.java( 隨 書 光 碟 myjava\ch0\ch_.java)
.. 抽 象 類 別 型 態 變 數.. 抽 象 類 別 型 態 變 數 /* 檔 名 :ch_.java 功 能 : 抽 象 類 別 型 態 的 變 數 */ package myjava.ch0; public class ch_ // 主 類 別 CShape objarr[] = new CShape[];// 抽 象 型 態 的 變 數 陣 列 objarr[0] = new CRect(.0,.0);// 變 數 參 考 子 類 別 物 件 實 體 objarr[] = new CRect(.0,.0); objarr[] = new CCircle(.0); objarr[] = new CCircle(.0); for(int i=0;i<objarr.length;i++) objarr[i].computearea(); // 執 行 子 類 別 改 寫 的 計 算 面 積 公 式 System.out.println(" 物 件 的 面 積 如 下 "); CShape.show(objArr); // 顯 示 面 積 CShape.sortByArea(objArr); // 進 行 排 序 System.out.println(" 物 件 依 面 積 排 序 後 如 下 "); CShape.show(objArr); // 顯 示 面 積 : 0 : : abstract class CShape 同 範 例 - 第 ~ 行 public abstract void computearea(); class CRect extends CShape // 子 類 別 CRect 繼 承 自 類 別 CShape 同 範 例 - 第 ~0 行 class CCircle extends CShape // 子 類 別 CCircle 繼 承 自 類 別 CShape 同 範 例 - 第 ~ 行 執 行 結 果 :( 同 範 例 -) 物 件 的 面 積 如 下 0.0.0..0 物 件 依 面 積 排 序 後 如 下..0.0 0.0 0. 本 章 回 顧 在 本 章 中, 我 們 學 習 了 Java 的 兩 個 重 點 類 別 繼 承 與 abstract 抽 象 方 法, 並 實 作 了 許 多 範 例, 重 點 整 理 如 下 : () 類 別 繼 承 是 基 於 已 經 存 在 的 類 別, 利 用 一 種 類 似 繼 承 的 動 作 來 取 得 相 同 類 別 的 機 制 這 對 於 程 式 設 計 師 來 說, 可 以 避 免 設 計 一 些 重 複 的 程 式 碼 ; 也 有 助 於 管 理 程 式 原 始 碼 () 被 衍 生 的 類 別 稱 為 父 類 別 (parent class) 或 基 底 類 別 (base class) 而 繼 承 衍 生 而 來 的 類 別 稱 之 為 子 類 別 (child class) 或 衍 生 類 別 (derived class), 父 類 別 和 子 類 別 有 其 先 後 和 相 似 的 關 係. 本 章 回 顧 () 子 類 別 保 留 了 父 類 別 中 的 非 私 有 成 員 的 使 用 權, 而 父 類 別 中 的 私 有 成 員 雖 然 無 法 被 子 類 別 存 取, 但 仍 舊 可 以 透 過 父 類 別 的 method 來 存 取 () 在 建 立 子 類 別 物 件 實 體 時, 會 先 執 行 父 類 別 的 建 構 子, 然 後 才 執 行 子 類 別 的 建 構 子 () 子 類 別 的 method 可 以 和 父 類 別 method 同 署 名, 此 情 況 稱 之 為 改 寫 (override) 改 寫 是 多 型 的 一 種 重 要 方 式 () 子 類 別 的 成 員 變 數 可 以 和 父 類 別 成 員 變 數 同 名, 並 且 不 會 將 父 類 別 的 變 數 覆 蓋, 而 是 將 繼 承 而 來 的 父 類 別 同 名 成 員 變 數 隱 藏 (hide) 此 時, 要 取 用 父 類 別 物 件 的 同 名 變 數, 可 以 透 過 super 關 鍵 字 來 達 成
. 本 章 回 顧 () 使 用 @Override 來 做 註 記 (annotation), 代 表 接 下 來 定 義 的 方 法 是 一 個 改 寫 方 法, 而 非 子 類 別 的 新 增 方 法 使 用 @Override, 編 譯 器 就 會 幫 程 式 設 計 師 在 編 譯 時 檢 查 該 類 別 的 父 類 別 中 是 否 定 義 了 同 署 名 的 方 法, 因 為 如 此 才 會 發 生 改 寫 當 然 在 實 際 應 用 時, 維 護 程 式 的 人 員 也 很 容 易 透 過 這 個 註 記, 辨 認 出 這 個 method 是 要 改 寫 父 類 別 的 method ()Java 的 一 般 類 別 繼 承 僅 提 供 單 一 繼 承 ( 不 直 接 提 供 多 重 繼 承 ), 並 可 透 過 多 次 繼 承 達 到 垂 直 的 多 層 繼 承 目 的 () 類 別 型 態 的 物 件 參 考 可 以 指 向 相 容 類 別 的 物 件 實 體, 此 處 所 謂 相 容 (compatible) 類 別 代 表 的 是 本 身 及 其 衍 生 類 別, 例 如 子 類 別 或 孫 類 別. 等 等. 本 章 回 顧 ()final 是 一 個 修 飾 字, 它 可 以 出 現 在 下 列 三 個 位 置, 在 不 同 位 置 有 不 同 的 意 義 : 宣 告 變 數 時 : 代 表 該 變 數 為 只 能 設 定 一 次 然 後 就 不 可 改 變 數 值 宣 告 於 類 別 的 method 時 : 代 表 繼 承 後, 不 可 被 改 寫 (override) 宣 告 於 類 別 時 : 代 表 該 類 別 不 可 被 繼 承 ( 終 止 繼 承 ). 本 章 回 顧 () 在 Java 中, 除 了 巢 狀 類 別 及 Object 類 別 之 外, 所 有 的 類 別 都 有 父 類 別, 並 且 若 使 用 者 未 定 義 該 類 別 的 父 類 別, 則 直 接 繼 承 自 Object 類 別 ()method 的 宣 告 若 在 前 面 加 上 abstract 關 鍵 字, 則 該 method 稱 為 抽 象 方 法 (abstract method), 並 且 若 一 個 類 別 包 含 了 abstract method, 則 必 須 宣 告 為 abstract class( 抽 象 類 別 ) () 抽 象 類 別 必 須 在 被 繼 承 後 改 寫 抽 象 方 法, 才 能 使 用 new 運 算 子 產 生 子 類 別 物 件 實 體 換 句 話 說,abstract class 只 能 被 用 來 繼 承 而 無 法 產 生 物 件 實 體