Microsoft PowerPoint - SE7ch07.ppt

Transcription

1 第七章物件導向設計 : 類別與物件 課前指引在本章中, 我們將正式進入物件導向程式設計的領域, 雖然我們在前面章節, 已經使用過某些 Java 類別庫的類別或物件 ( 例如 :Math 類別 String 物件 ), 但卻未曾學習如何建立一個物件 ( 事實上建立物件必須先宣告類別 ) 在本章中, 我們將從頭教您如何使用 Java 並以物件觀點設計程式, 逐漸體驗物件導向程式設計帶來的好處, 尤其是在發展中大型專案時, 物件導向程式設計更是目前最佳的解決之道 章節大綱 7.1 物件導向程式設計 7.2 物件導向的三大特性 7.3 Java 的類別 7.4 Java 的物件 7.5 方法 7.7 物件引數的傳參考值呼叫 7.8 this 關鍵字 7.9 物件陣列 7.10 類別變數與類別方法 7.11 本章回顧 7.6 建構子

2 7.1 物件導向程式設計 Java 是一個物件導向程式語言 (OOPL; Object-Oriented Program Language) 所謂物件導向設計理念, 就是利用軟體模擬現實生活中實體所擁有的特性與行為, 這些實體就是物件, 而每一個物件都可以擁有各自的屬性及方法物件導向程式設計 (OOP ;Object-Oriented Programming) 是一種以物件觀念來設計程式的程式設計技巧, 它透過物件的方法產生互動以完成程式要求 物件導向程式設計 在純物件導向的程式中, 每一個運作實體都可視為某種類別衍生出來的物件 而類別則較具抽象的概念, 也就是某些具有共同特性物件的集合換句話說, 物件就是類別的實體 物件導向具有封裝 繼承 多型等特性, 原則上每個物件相互獨立且無關聯性而物件導向程式設計就是依照物件的方法產生互動以完成要求 4

3 7.1 物件導向程式設計 傳統的結構化程式設計將問題切割成許多小問題 ( 模組 ), 由於這些模組的存在目的是為了解決大問題而設計的, 因此, 這些模組可能會存取同一個資料結構, 這將導致模組之間的獨立性質降低舉例來說, 某兩個模組可能都會修改陣列資料結構中的元素, 因此當我們希望將某一個模組的操控對象從 陣列 改為其他的資料結構時, 另外一個模組也必須跟著改變 因此, 結構化程式設計雖然對於某些問題可以快速尋得解決方案, 但對於日後的維護則顯得不足 物件導向程式設計 故後來又發展了以物件為基礎的程式語言 並且又可以分為物件基礎程式語言與物件導向程式語言兩類 這兩類程式語言都是以物件為出發點, 藉由物件與物件之間的互動完成問題的解答, 比較符合真實世界環境 物件基礎程式語言最著名者為 JavaScript 它允許設計者使用物件來設計程式, 但無法提供繼承等機制來擴充程式, 不利於大型程式的開發, 因此常用於客戶端網頁等程式設計 Java 是物件導向程式語言 提供完整的繼承 封裝 多型等特性, 適合開發大型程式 6

4 7.1 物件導向程式設計 物件之間的互動是透過訊息 (Message) 的傳遞來達成 發送訊息的物件稱之為發送者 (sender) 接受訊息的物件稱之為接收者 (receiver) 當物件需要其他物件服務時, 會發送訊息給接收者, 接收者在收到訊息後, 會執行符合要求的方法完成任務以提供服務 由於每一個物件都是一個獨立的個體, 因此改良某一物件的內容時, 其他不同類別的物件並不需要跟隨著變動 如此一來, 在尋求大型或超大型方案的解答時, 不但比結構化程式設計容易分析問題, 更有助於日後的維護與修改 物件 (object) 真實世界中的所有具體或抽象的事物, 都可以將之視為一個 物件 例如 : 您可以把一架飛機想像成是一個物件 (Object) ; 而飛機的零件 ( 例如 : 座椅 引擎 操縱桿 ) 則是較小的物件明顯地, 這些物件仍舊可以再細分為更小的物件 ( 例如 : 螺絲釘 ) 在程式設計中,Java 的物件實際上是一些程式碼和資料的組合, 物件必須能夠單獨成為一個完整單元, 也可以組合成更大的物件 例如 : 一個按鈕或一個表單都是一個物件 而一個應用程式最大的物件就是應用程式的本身 8

5 7.1.1 物件 (object) 屬性 (Property) 物件擁有許多特性 (attribute), 這些特性代表了一個物件的外觀或某些性質例如 : 民航機物件的最高速度就代表了該飛機的一種特性 民航機物件的重量 載重量 等等也都可以用來代表飛機的某些特性這些特性在物件導向程式設計中稱之為屬性 (Property) 事實上, 有的時候在取得物件的某些屬性時, 所得到的也可能是另一個 ( 子 ) 物件 ( 若該屬性的資料型態是一個類別 ) 例如 : 民航機的引擎也是一個物件, 因為它可以由更多更小的零件來組成, 同時引擎物件也存在自己的方法 (Method), 例如 : 引擎點火 在程式設計或執行階段, 我們可以藉由改變屬性值來改變整個物件的某些特性, 完成我們想要的物件表示形式 例如 : 將民航機物件的機殼漆成藍色, 將按鈕背景顏色設為黃色 物件 (object) 在 Java 語言中, 屬性 (Property) 被稱為 Field( 有人翻譯為欄位 ; 本書有時也翻譯為成員資料變數 ), 並且被區分為不同的等級 某些等級的成員資料變數並不允許外部程式加以修改, 而必須透過該物件的方法, 才能夠修改這些成員資料變數 因此具備保護資料的功能 10

6 7.1.1 物件 (object) 方法 (Method) 每個物件都擁有不同數量的行為 (method), 這些行為在物件導向程式設計中稱之為方法 (Method) 不同種類的物件所擁有的方法大多不同, 但同類物件擁有的方法則大致相同 所謂方法, 也就是為了完成該物件某些目標的處理方式 例如 : 飛機類別的物件有許多方法使得飛機變得有些用途, 這些方法如起飛 降落 逃生等等 每個方法都有許多的細節例如起飛, 可能包含 發動引擎 直到拉動操縱桿, 這些就是起飛方法的細節 物件 (object) 在 Java 中, 方法也稱之為 method( 有些書籍翻譯為方法 ; 本書翻譯為方法或函式, 也就是成員函式 ) 同時 Java 的 method 也和 Field 一樣, 被區分為多種等級 某些等級的成員函式同樣不允許外部程式呼叫執行 ( 只能做為內部成員函式呼叫執行的對象 ) 因此達到封 對於某些由他人完成的物件而言, 該物件同樣必須提供許多關於物件的方法, 如此一來, 我們就不需要了解這些方法的細節, 而能夠快速運用物件來完成工作 例如飛機物件提供了起飛方法, 我們只要指定執行起飛方法, 而不需要了解起飛過程的種種細節, 飛機就會起飛 裝物件的功能 12

7 7.1.1 物件 (object) 圖 7-1 類別與物件關係圖 類別 (class) 類別 物件雖然是獨立的個體, 不同的物件可以擁有相同的屬性及方法, 例如 : 一架民航機 和 一架戰鬥機 各是一個物件, 但兩者的速度 爬升力 重量 載重量雖不相同, 但卻同樣擁有這些屬性以便表達完整物件的各個特性 所以, 不同的物件若擁有共同的屬性, 但因為屬性內容的不同, 因此可以創造出同類性質但卻獨立的不同物件 而同類型的物件, 則構成了類別 (Class) 例如每一個按鈕都是一個物件, 屬於按鈕類別之下所建造出來的物件實體, 但是由於按鈕的名稱不同, 因此視為不同且獨立的物件 14

8 7.1.2 類別 (class) 更明確地說, 類別才是物件導向程式設計最基本的單元 以上例來說, 民航機 和 戰鬥機 都是物件, 而 飛行器 或 飛機 才是類別 不同的只是在建立該類別的實體物件時, 給予不同的屬性而已 事實上, 在實際的物件導向程式設計中 ( 例如 Java), 我們必須先定義類別, 然後才能夠透過類別宣告各個屬於該類別下的物件, 接著再設定物件的屬性來代表該物件某方面的特性, 並使用物件的方法來操作物件 類別 (class) 從由下而上的角度來看, 類別是許多同類物件的集合所謂同類物件, 代表擁有相同屬性 ( 資料變數 ) 及方法 ( 函式 ) 的物件例如 : 每一台 飛行器 類別下的物件, 都包含 速度 爬升力 重量 載重量 等變數, 也包含 起飛 降落 逃生 等方法, 以便完成工作 由於我們可以將這些變數設定為不同的屬性值, 因此可以在該類別下造就各式各樣的物件如同 民航機 和 戰鬥機 各是一個物件, 而 飛行器 則是類別 在純物件導向的程式中程式碼是以類別為基礎物件只是類別的實體就如同汽車是一個類別, 它是一個抽象的名詞而車牌號碼為 等的車輛是汽車類別的兩個物件實際運作時 通常 依靠的是物件 我們將於下一小節中, 更深入介紹物件導向程式語言的特性 16

9 7.1.2 類別 (class) 老師的叮嚀 有些人在說明類別與物件的關係時, 會將類別視為一種板模, 而物件則是依靠板模建立出來的實體, 就如同雞蛋糕板模是類別, 而每一個實際做出來可以吃的雞蛋糕是物件 這種比喻方式在某種程度上說得通, 不過仍舊不能完全說明 Java 類別與物件的實際應用, 因為 Java 也允許在未產生物件實體時, 存取變數或執行方法, 也就是靜態變數與靜態方法 圖 7-2 類別生成物件 物件導向的三大特性 物件導向程式設計具有某些特點如下, 使得它更適合用以開發 管理大型程式 封裝性 繼承性 多型性 封裝性 (encapsulation): 封裝性可以將物件區分為可被外界使用的特性及受保護的內部特性 ; 換句話說, 除非是允許外部程式存取的資料, 否則外部程式無法改變物件內的資料 如此就能夠達到封裝保護資料的特性 更細分來說, 物件導向程式設計將物件的資料與方法至少區分為三種等級 :(Java 除了下列等級之外, 尚有 Package 等級 ) public private protected : 公用等級 : 私用等級 : 保護等級 18

10 7.2 物件導向的三大特性 其中私用 (private) 等級的資料與方法, 只允許相同類別內的程式碼取用而保護 (protected) 等級的資料與方法, 只允許相同類別及衍生類別 ( 何謂衍生類別後述 ) 的程式碼取用至於公用 (public) 等級的資料與方法, 則開放給任何程式碼取用 圖 7-3 封裝性 物件導向的三大特性 機房物件公開屬性 : 原料 成品 私有屬性 : 水 公開方法 : 使用純水 使用礦泉水 方形餅乾製作 星形餅乾製作 圓形餅乾製作 私有方法 : 機器 A 啟動 機器 B 啟動 機器 A 快轉 以圖 7-3 為例, 一個講究衛生的食品餅乾工廠, 其內部機房就具有封裝特性對外, 它只開放原料與成品兩個可存取的屬性, 並且提供製作方形餅乾 製作星形餅乾 製作圓形餅乾等操作方法的按鈕 原料屬性對外是可存取的, 例如您可能放入的是三號麵粉, 但也可以改為二號麵粉 成品也是可以存取的, 例如您可以把餅乾吃掉 裝箱或捏碎報廢 被封裝的屬性則是不可存取的, 除非透過外部方法間接存取例如製作過程中, 可能需要水, 而我們無法直接變動水的種類, 必須透過對外的外部方法 ( 也就是純水或礦泉水按鈕 ) 來完成換句話說, 在這個範例中, 我們無法隨意將水變更為海洋深層水, 因為我們無法直接進入到機房內部 20

11 7.2 物件導向的三大特性 同理, 由於我們無法進入機房內部直接操作機器, 所以只能透過對外操作面板上的三個按鈕選擇要執行的製作程序 當我們按下某一個按鈕時, 相當於呼叫機房物件的一個公開方法 此方法的細節則可以動用到機房內的所有資源 可是機房的設計一但完成後, 這些方法的細節也就固定了 對於使用機房物件的使用者而言 他只能選擇執行某一個按鈕方法, 而無法更動按鈕方法的執行內容細節 物件導向的三大特性 更進一步來說, 假設我們是設計機房物件的程式設計師這代表著我們可以進入機房, 也可以設計各種餅乾的製作細節但即使進入了機房, 當我們面對每一台機器時, 由於每一台機器也都是一個物件 ( 同樣也具有封裝性 ), 故我們只能操作機器對外的按鈕, 而無法進入機器的內部 因此, 封裝性使得問題變為分層負責的狀態, 更符合生活上的作事原則 設計物件者有責任將物件設計的完整且不會出錯, 也需要留下一些對外可操作的方法, 必要時也可留下一些外部可存取的屬性 而使用物件者, 則只能夠透過物件對外的屬性與方法來利用物件達到自己的需求 小試身手 7 1 電子鬧鐘 物件具有封裝性, 試以電子鬧鐘為例, 說明電子鬧鐘的哪一些屬性為公開屬性? 哪一些為私有屬性? 哪一些為公開方法? 哪一些為私有方法? 22

12 7.2 物件導向的三大特性 繼承性 (inheritance): 繼承性是為了達成重覆使用目的所採取的一種策略例如 : 一個滑鼠類別只要加上滾輪裝置, 就變成了滾輪滑鼠但滾輪滑鼠也同樣可以上下左右移動改變指標位置, 也可以按兩下執行程式, 只不過現在又多了一個滾輪使得瀏覽網頁時更加方便因此, 這個滾輪滑鼠類別可繼承滑鼠類別再加以擴充 在物件導向程式設計中, 允許使用者定義基底類別 (base class) 與衍生類別 (derived class) 其中衍生類別允許繼承基底類別的屬性及方法, 並 加入新的屬性及方法 或者改寫 (override) 某些繼承的方法, 改成適用於本身的方法 有了這項特性, 在開發大型程式時, 我們就可以延續已經完成的技術, 再加以擴充 物件導向的三大特性 圖 7-4 繼承性 24

13 7.2 物件導向的三大特性 多型性 (Polymorphism): 就多型性而言, 其實它是一個非常抽象的名詞, 代表著一種彈性 舉例來說, 所謂開水人人會煮, 各有巧妙不同, 基本上, 瓦斯爐 電磁爐 熱水瓶都可以煮開水, 所以 煮開水 其實是一個相當抽象的名詞使用瓦斯爐 電磁爐 熱水瓶的煮開水方式都不一樣, 但 煮開水 一詞卻涵蓋了這些差異性的行為, 而此種特質則稱為 多型性 多型的實作方法有很多種其中一種是改寫 (override; 或稱覆寫 ), 它與繼承有關例如瓦斯爐衍生類別 電磁爐衍生類別 熱水瓶衍生類別都繼承自加熱器基底類別, 該基底類別中定義了加熱的方法, 我們則必須在衍生類別內, 改寫這個方法, 使得加熱的細節有所不同如此一來, 由不同衍生類別所產生的物件, 執行方法時的細節就會不同了 物件導向的三大特性 圖 7-5 多型性 26

14 7.2 物件導向的三大特性 另一種屬於多型的技術稱之為多載 (overload) 它允許程式中出現相同名稱但不同署名的函式, 我們在上一章已經介紹過了 由以上兩種多型的機制可知, 多型是一種呼叫相同名稱函式, 但卻可執行不同函式內容的機制, 因此, 又有人將 多型 稱之為 同名異式 編譯器在實作多型的功能時, 依靠的是動態繫結來達成 傳統上 ( 在非物件導向語言中 ), 我們在呼叫函式時, 必定會註明要呼叫哪一個函式, 而編譯器在編譯階段就可以知道各個函式在記憶體中的位址 ( 當然這是個相對位址 ), 因此只要我們註明了要呼叫哪一個函式, 編譯器在編譯階段就可以將該位址記錄在機器碼中, 所以執行到該機器碼指令時, 就會去呼叫那一個函式, 不可能執行別的函式 物件導向的三大特性 而動態繫結則是 程式碼中可能有好幾個同名的函式, 我們雖然指明了要執行哪一個名稱的函式, 但並未完全指定要執行同名中的哪一個函式 因此, 編譯器在處理這種函式呼叫時, 會編譯為由傳入引數來決定要執行哪一個函式, 而這個引數將會是函式的起始位址, 所以只有等到程式真的執行到該機器碼並傳入引數時, 才會知道要執行的是哪一個函式 28

15 7.2 物件導向的三大特性 上述物件導向設計的三大特性,Java 當然全部都支援在本章中, 您將學習到 Java 如何完成物件導向中軟體元件的封裝性 並且在本篇的後面章節將介紹 Java 的其他程式設計技巧這些設計技巧將足以完成物件導向設計的繼承性及多型性 經過以上的介紹, 相信您對於物件導向設計有了初步的概念, 在進入下面的內容之前, 我們再說明一次關於 Java 的物件與類別 物件是由類別所衍生, 例如透過 String 類別, 我們可以宣告一個 String 物件 而物件名稱是一個參考 透過 new 我們可以產生物件的實體, 並將某一個物件名稱指向它, 以便操作該物件 因此, 類別有 fields 與 methods, 而該類別衍生的物件也有相同的 fields 與 methods Java 的類別 還記得我們在介紹陣列時, 曾說明陣列是將相同資料型態的變數集合起來形成一個結構嗎? 而類別則可以將不同資料型態的變數集合起來形成一個結構這些變數將成為類別的成員不僅如此, 我們還可以為類別定義屬於該結構的函式 類別是物件導向程式最基本的單元, 是產生同一類物件的基礎類別可以由使用者自行定義, 以下是在 Java 中定義類別的語法 : 30

16 7.3 Java 的類別 定義類別語法 : [ 封裝等級 ] [ 修飾字 ] class 類別名稱 [extends 父類別 ] [implements 介面 ] [ 封裝等級 ] [ 修飾字 ] 資料型態 field 名稱 1; [ 封裝等級 ] [ 修飾字 ] 資料型態 field 名稱 2; 宣告 fields : : [ 封裝等級 ] [ 修飾字 ] 回傳值資料型態 method 名稱 1( 參數串宣告 ) method 的內容 定義 method [ 封裝等級 ] [ 修飾字 ] 回傳值資料型態 method 名稱 2( 參數串宣告 ) method 的內容 定義 method : : : Java 的類別 語法說明 : (1) 類別定義的第一行, 我們可以視為類別的宣告 當中所有的 [] 都可以省略, 因此我們暫不討論 ( 後面會陸續介紹 ) 而其中類別的 [ 封裝等級 ], 只有 public 或不出現兩種, 當 出現 public 時, 代表該類別為 主類別, 而主類別必須與檔名取相同的名稱 同時, 只有被宣告為 public 的類別才能被 import 進來 在本章中, 我們宣告類別時, 都不會出現該欄位 ( 除主類別外 ) (2) 在類別中定義的資料與函式, 分別稱為 fields 與 methods 關於 fileds 及 methods 的翻譯與物件導向設計的對照請見下表 32

17 7.3 Java 的類別 Java 原始物件導向設計 C++ 本書翻譯其他說明文件 field 屬性 (Property) 成員變數資料欄位 成員變數 成員資料 屬性有時不翻譯 method 方法 (Method) 成員函式函式 成員函式 方法有時不翻譯 表 7-1 filed 與 method 翻譯對照表 (3) 類別中可以對 fileds 及 methods 定義多種 封裝等級 如下, 在本章中, 我們將先說明 公用等級 及 私用等級, 而 保護性等級 則留待繼承一章中再做說明 如果省略宣告成員的封裝等級, 則該成員只能被同一個 Package 的類別存取, 而無法被不同 Package 的類別存取, 此稱為 package 封裝等級 ( 詳見第 11 章 ) Java 的類別 public: 公用等級資料型態 private: 私用等級資料型態 protected: 保護性等級資料型態 空白 :package 等級 (4) 在類別中, 不同的存取等級 代表 不同的資料保護方式, 資料之所以需要保護, 主要是為了讓各類別的資料獨立開來, 不易被其他不相干的函式修改, 達到物件導向程式設計中, 資料封裝 及 資料隱藏 的功能 (5) 根據上述定義類別的語法, 我們可以利用下圖來示意類別的內部結構 :( 當中省略了 package 等級 ) 34

18 7.3 Java 的類別 圖 7-6 資料等級 ( 省略 package 等級 ) (6) 私用等級資料只能被同一個類別的成員函式存取 ; 而公用等級的資料則除了類別內的成員可以存取之外, 其他外部的函式也都可以存取宣告為公用等級的資料 Java 的類別 (7) 宣告 fields 與定義 methods 的順序可以交錯 (8)field 可以設定初值且該初值會在物件實體產生時, 自動被設定 (9) 類別的命名在第二章曾經提過, 本書所採用的習慣為第一個字母大寫 ( 通常命為 C, 代表 class), 其後由一個以上的單字所組成, 每個單字的開頭字母為大寫, 其餘為小寫例如 :CPerson,CStack,CCircularQueue 範例 1 定義一個 CStudent 類別, 將其成績 地址 電話宣告為 私用等級資料型態 ; 學號 姓名 科系宣告為 公用等級資料型態 36

19 7.3 Java 的類別 class CStudent private float score; private String address; private int phone; public int id; public String name; public String major; 或 class CStudent private float score; public int id; private int phone; public String name; private String address; public String major; 相同封裝等級的不一定要擠在一起 Java 的類別 範例 2 延續範例 1, 在 CStudent 類別中, 宣告兩個 公用等級 的 ( 成員 ) 函式, 分別為 showid( ) 和 showmajor( ), 函式用途分別為 顯示學號 及 顯示科系 class CStudent private float score; private String address; private int phone; public int id; public String name; public String major; 顯示並回傳學號, 回傳型態為 int public int showid( )... public void showmajor( )... 顯示科系, 回傳型態為 void 38

20 7.3 Java 的類別 或 class CStudent private float score; private String address; private int phone; 顯示並回傳學號, 回傳型態為 int 範例說明 : public int showid( )... public void showmajor( )... public int id; public String name; public String major; 顯示科系, 回傳型態為 void 上述範例, 當物件被實際建立之後,id,name,major 可以被外部函式所取用,showId() 與 showmajor() 也可以被外部程式所執行, 但 score address 與 phone 只能被同一類別的成員函式存取 ( 例如 showid 成員函式 ) Java 的物件 類別是許多資料變數及函式合成的抽象資料型態, 和陣列很相似 當我們想要使用類別時, 必須透過宣告變數並產生實體後才能夠使用 ( 除了僅使用被宣告為 static 的變數與方法外 ) 而由類別宣告的變數, 稱之為物件參考或物件變數 而產生的實體則稱為物件實體 (instance) 對照圖 7-1, 我們可以將 Java 的類別與物件重新描述如下圖 : 40

21 7.4 Java 的物件 圖 7-7 Java 類別與物件關係圖 ( 請與圖 7-1 對照比較 ) 宣告物件變數與產生物件實體 宣告物件變數宣告物件變數與宣告一般變數差不多, 只不過是把原始資料型態改為類別名稱, 語法如下 : 類別宣告物件變數語法 類別名稱物件變數名稱 ; 語法說明 : 上述語法可以出現在任何類別內, 也可以出現在任何 method 內 當宣告物件變數後, 由於物件變數是一個參考, 故開始時並未指向任何實體, 此時的內容會被初始化為 null 範例 : 宣告一個 CStudent 類別的物件變數, 名稱為 John 42

22 7.4.1 宣告物件變數與產生物件實體 class CStudent 類別定義 CStudent John; // 宣告物件變數 John, 本敘述應出現在類別或方法內 範例 : 宣告一個 String 類別的物件變數, 物件名稱為 str1 import java.lang.string; String str1; // 宣告 String 物件變數 str1, 本敘述應出現在類別或方法內 說明 String 類別已經被定義於 java.lang Package, 故載入該類別即可 宣告物件變數與產生物件實體 產生物件實體產生物件實體使用的是 new 運算子, 語法如下 : 產生物件實體語法 物件變數 = new 類別名稱 ( 引數 1, 引數 2 ); 語法說明 : 這個語法由於不屬於變數宣告, 故只能出現在 method 內 上述語法除了可以產生物件實體, 並將實體的參考設定給物件變數之外, 還可以透過引數串列呼叫特定的建構子 建構子 (Constructor) 是一個特殊的函式, 可以在物件實體產生時, 進行一些初始化動作 如果不需要傳遞引數, 則可以省略引數串列 範例 : 為 CStudent 類別的物件變數 John 產生一個實體 John = new CStudent(); 44

23 7.4.1 宣告物件變數與產生物件實體 範例 : 為 String 物件變數 str1 產生一個實體並設定其初始值為 "Hello" str1 = new String("Hello"); 說明 String 類別不是我們所開發的類別, 其建構子 (Constructor) 已經由 JDK 完成在 Java 說明文件中, 可以查詢 Constructor Summary 文件段, 會發現許多與類別同名的函式, 這些函式就是建構子 宣告物件變數與產生物件實體 宣告物件變數並產生實體我們可以於宣告物件變數時, 同時產生物件實體, 語法如下 : 類別名稱物件變數名稱 = new 類別名稱 ( 引數 1, 引數 2 ); 語法說明 : 上述語法只是將之前的兩個語法合併 上述語法可以出現在任何類別內, 也可以出現在任何 method 內 範例 : 宣告 CStudent 類別的物件變數 John, 並產生一個實體, 使 John 指向該實體 CStudent John = new CStudent(); 範例 : 宣告 String 物件變數 str1, 並產生一個實體, 實體內容初始化為 "Hello", 並使 str1 指向該實體 String str1 = new String("Hello"); 46

24 7.4.2 存取成員變數與執行成員函式 當物件實體被產生以後, 我們就可以合法存取公用等級的 fields 以及執行公用等級 methods( 如果敘述處於同一類別則不限封裝等級皆可存取 ) 而且存取方法很簡單, 只要在物件與欲取用資料之間加上. 運算子即可, 如下語法 : 存取成員資料與執行成員函式語法 物件. 成員資料物件. 成員函式 ( 引數 1, 引數 2, ) 存取成員變數與執行成員函式 語法說明 : (1) 私用資料與函式, 只能被同一類別內的成員函式存取與呼叫 ( 至於保護資料與函式則留待繼承一章再作說明 ) (2) 上述語法是外部程式的存取與呼叫語法 如果是同一類別內的存取與呼叫, 則不需要指定物件, 因為當它被執行時, 它已經是物件本身 範例 1 將 John 物件的 id 變數設定為 , 設定 John 物件的 name 變數為 "John" John.id = ; John.name="John"; 範例 2 透過 showmajor() 成員函式顯示 John 的科系名稱 John.showMajor(); 48

25 7.4.2 存取成員變數與執行成員函式 錯誤範例 私用資料與函式, 只能被類別內的成員函式存取, 所以下列是錯誤的敘述 : public class 主類別名稱 static CStudent John; public static void main(string args[]) John = new CStudent(); John.score = 85.5; // 錯誤, 因為 score 是私用資料 John.address=" 台北市大安區 "; // 錯誤, 因為 address 是私用資料 觀念範例 7-1 : 定義類別 宣告物件並存取物件的公用成員資料 範例 7-1:ch7_01.java( 隨書光碟 myjava\ch07\ch7_01.java) 存取成員變數與執行成員函式 /* 檔名 :ch7_01.java 功能 : 定義汽車類別與宣告 3 個物件 */ package myjava.ch07; import java.lang.*; public class ch7_01 // 主類別 public static void main(string args[]) CCar bus = new CCar(); 宣告 CCar 類別下的 3 個物件變數並產 CCar truck = new CCar(); 生實體, 物件名稱分別為 CCar taxi = new CCar(); bus,truck,taxi bus.name=" 公車 "; bus.wheel=6; bus.person=40; truck.name=" 卡車 "; truck.wheel=8; truck.person=3; taxi.name=" 計程車 "; taxi.wheel=4; taxi.person=5; //taxi.engine="v16"; 可存取公用等級的變數 不可存取私用等級的變數 50

26 7.4.2 存取成員變數與執行成員函式 System.out.print(bus.name + " 有 " + bus.wheel + " 個輪子 "); System.out.println(", 可載 " + bus.person + " 人 "); System.out.print(truck.name + " 有 " + truck.wheel + " 個輪子 "); System.out.println(", 可載 " + truck.person + " 人 "); System.out.print(taxi.name + " 有 " + taxi.wheel + " 個輪子 "); System.out.println(", 可載 " + taxi.person + " 人 "); class CCar public int wheel; public int person; public String name; private String engine; 定義 CCar 類別, 包含 3 個公用等級變數 wheel person name, 以及一個私用等級變數 engine 執行結果 : 公車有 6 個輪子, 可載 40 人卡車有 8 個輪子, 可載 3 人計程車有 4 個輪子, 可載 5 人 存取成員變數與執行成員函式 範例說明 : (1) 當成功編譯此範例後, 您會發現目錄底下除了 ch7_01.class 之外, 還會出現 CCar.class 檔, 這是因為我們除了主類別外, 另外又定義了一個類別 CCar (2) 第 14~16 行, 設定 bus 物件的公用等級變數 第 18~20 行, 設定 truck 物件的公用等級變數 第 22~24 行, 設定 taxi 物件的公用等級變數 (3) 第 25 行是不合法的敘述, 因為 engine 是私用變數, 所以不允許外部程式 ( 非同類別的函式敘述 ) 存取該變數 ( 但允許相同類別下的各級成員函式存取, 詳見下一節 ) 52

27 7.5 方法 方法 (method) 又稱為成員函式, 它與成員變數一樣, 除空白 ( 未宣告封裝等級 ) 的 package 等級之外, 封裝等級還可宣告為 public private protected 等三種等級 並且只有 public 等級的成員函式可以被外部程式 ( 非同類別的函式敘述 ) 呼叫執行而 private 等級的成員函式只能被其他同類別的成員函式呼叫執行但不可以被外部程式呼叫執行至於 protected 等級的成員函式則留待繼承一章再作說明 方法 到目前為止, 我們了解到 private 等級的成員變數或函式無法被外部程式所取用與執行, 因此能夠達到物件導向 封裝 的目的 而 public 等級的成員變數或函式可以被外部程式所取用與執行, 是物件導向封裝時對外唯一的管道, 同時 private 等級的成員變數或函式也可以被 public 等級的成員函式呼叫因此外部程式如果想要取用 private 等級的成員變數, 可以先呼叫 public 等級的成員函式, 再由 public 等級的成員函式修改 private 等級的成員變數, 如此不但達到封裝的目的, 也可以在類別中增加了設計程式的彈性 54

28 7.5 方法 圖 7-8 外部程式存取 private 等級的資料必須透過 public 等級的方法來完成 定義方法 在上一章我們已經提過如何在主類別內定義函式, 由於 Java 的函式必定隸屬於某一個類別, 故語法大致相同只不過, 您必須把函式定義放在類別內部 以下是定義方法的詳細語法 : 在類別內定義成員函式語法 [ 封裝等級 ] [ 修飾字 ] class 類別名稱 [extends 父類別 ] [implements 介面 ] 在類別內定義成員函式語法 [ 封裝等級 ] [ 修飾字 ] 回傳值資料型態 method 名稱 // 定義 method method 的內容 語法說明 : 關於 [ 修飾字 ] 部分, 我們暫時省略, 而封裝等級則為 public private protected 或不填 56

29 7.5.1 定義方法 範例 請宣告並定義 CMyClass 類別中的相關成員函式如下 : 公用等級的成員函式 funca, 不接受任何引數, 也無回傳值 公用等級的成員函式 funcb, 接受兩個整數引數, 並回傳一個整數回傳值 私用等級的成員函式 funcc, 不接受任何引數, 也無回傳值 class CMyClass public void funa() // 公用成員函式 成員函式定義 public int funcb(int m,int n) // 公用成員函式 成員函式定義 private void funcc() // 私用成員函式 成員函式定義 透過成員函式存取私用性資料變數 私用性 (private) 資料變數無法被外部程式存取, 但可以透過同一類別的成員函式 ( 等級無限制 ) 來存取它, 彈性應用私用的資料變數 觀念範例 7-2 : 透過公用成員函式存取私用資料與成員函式 範例 7-2:ch7_02.java( 隨書光碟 myjava\ch07\ch7_02.java) /* 檔名 :ch7_02.java 功能 : 透過公用成員函式存取私用資料與成員函式 */ package myjava.ch07; import java.lang.*; 58

30 7.5.2 透過成員函式存取私用性資料變數 public class ch7_02 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(); CMyClass Y = new CMyClass(); X.initVar(); Y.initVar(); 執行結果 物件 X Var=11 物件 Y Var=6 物件 Y Var=9 // 在 X 物件上, 執行 initvar 成員函式 // 在 Y 物件上, 執行 initvar 成員函式 X.addVar(10); // 在 X 物件上, 執行 addvar 成員函式 System.out.print(" 物件 X\t"); X.showVar(); System.out.print(" 物件 Y\t"); Y.addVar(5); // 在 Y 物件上, 執行 addvar 成員函式 Y.showVar(); System.out.print(" 物件 Y\t"); Y.addVar(3); // 在 Y 物件上, 執行 addvar 成員函式 Y.showVar(); 透過成員函式存取私用性資料變數 class CMyClass public void initvar() Var=1; public void addvar(int b) Var=Var+b; public void showvar() realshow(); // 執行 private 等級的函式 private int Var; private void realshow() System.out.println("Var=" + Var); 不可被外部程式存取與執行, 但可被同類別的函式存取與執行 60

31 7.5.2 透過成員函式存取私用性資料變數 範例說明 : (1) 第 32~43 行, 定義了 3 個公用的成員函式, 可以被外部程式執行 第 44~48 行, 宣告了 1 個私用的變數及定義了一個私用成員函式, 不可以被外部程式存取與執行 (2) 變數 Var 與成員函式 realshow 雖然不能夠被外部程式存取與執行, 但可以被同一類別的成員函式存取與執行, 例如第 行 (3) 程式執行時, 記憶體內部呈現下列變化 Step1: 第 10~11 行執行完畢, 記憶體中將同時存在兩個物件變數 X,Y 以及它的實體 由於我們並未定義建構子, 因此 Java 會執行預設的建構子 ( 不做任何事 ), 並且所有的成員都會被自動初始化 由於 Var 是 int 型態, 故為 透過成員函式存取私用性資料變數 ( 下圖是記憶體的變化, 由於尚未介紹 static method, 故省略 main 在記憶體資料區的狀況 ) 62

32 7.5.2 透過成員函式存取私用性資料變數 Step2: 執行第 13 行, 執行完畢時,X 的成員變數 Var 被設定為 1 ( 下圖中, 我們省略了部分的記憶體程式區 ) 透過成員函式存取私用性資料變數 Step3: 執行第 14 行, 執行完畢時,Y 的成員變數 Var 被設定為 1 64

33 7.5.2 透過成員函式存取私用性資料變數 Step4: 執行第 16 行, 執行完畢時,X 的成員變數 Var 被設定為 透過成員函式存取私用性資料變數 Step5: 執行第 17~18 行, 執行完畢時, 印出 X 的成員變數 Var 為 11 Step6: 執行第 21 行, 執行完畢時,Y 的成員變數 Var 被設定為 6 66

34 7.5.2 透過成員函式存取私用性資料變數 Step7: 執行第 22 行, 執行完畢時, 印出 Y 的成員變數 Var 為 6 Step8: 執行第 25 行, 執行完畢時,Y 的成員變數 Var 被設定為 9 Step9: 執行第 26 行, 執行完畢時, 印出 Y 的成員變數 Var 為 透過成員函式存取私用性資料變數 在範例 7-2 中, 我們必須先呼叫 initvar 函式將成員變數的初始值設定為 1 是否有 更簡便 的方式可以進行這樣的工作呢? 答案是有的第一種方式是將成員變數於宣告時設定初始值 ( 如範例 7-3) 另一種方式則是透過建構子來設定 ( 如範例 7-4) 觀念範例 7-3 : 改寫範例 7-2, 將成員變數設定初始值, 完成相同的初值設定效果 範例 7-3:ch7_03.java( 隨書光碟 myjava\ch07\ch7_03.java) 68

35 7.5.2 透過成員函式存取私用性資料變數 /* 檔名 :ch7_03.java 功能 : 成員變數設定初始值 */ package myjava.ch07; import java.lang.*; public class ch7_03 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(); CMyClass Y = new CMyClass(); X.addVar(10); // 在 X 物件上, 執行 addvar 成員函式 System.out.print(" 物件 X\t"); X.showVar(); System.out.print(" 物件 Y\t"); Y.addVar(5); // 在 Y 物件上, 執行 addvar 成員函式 Y.showVar(); System.out.print(" 物件 Y\t"); Y.addVar(3); // 在 Y 物件上, 執行 addvar 成員函式 Y.showVar(); 透過成員函式存取私用性資料變數 class CMyClass public void addvar(int b) Var=Var+b; public void showvar() realshow(); private int Var=1; // 設定初始值 private void realshow() System.out.println("Var=" + Var); 當物件實體產生時, 物件的 Var 成員就被設定為 1 執行結果 :( 同範例 7-2) 範例說明 : 第 37 行,Var 成員變數被設定了初始值為 1, 因此不需要 initvar() 函式, 因為當物件實體產生時, 物件的 Var 成員就被設定為 1 70

36 7.6 建構子 在範例 7-2 中, 我們必須先呼叫 initvar 函式將成員變數的初始值設定為 1 雖然這個工作可以透過設定成員變數初始值來完成 ( 如範例 7-3), 但當我們希望初始值與物件實體產生時有關 ( 而非一個單純的常數 ) 時, 就無法單單透過設定成員變數初始值來完成了 建構子 如果在產生物件實體時, 能夠自動幫我們呼叫某個特定函式, 進行某些初始化動作, 不是使得設計程式方便多了嗎? 是的,Java 如同其他的物件導向語言一般, 也考慮到了這一點, 因此可以在建構子中來完成這些事情 建構子 (Constructor) 又稱建構函式, 它是生成物件實體時會自動執行的函式 由於它很特別, 因此定義語法與一般成員函式有些不同, 語法如下 : 72

37 7.6 建構子 [ 封裝等級 ] 建構函式名稱 ( 參數串 ) // 建構函式名稱就是類別名稱 建構函式內容 語法說明 : (1) 建構函式名稱一定要和類別名稱相同 (2) 不可加上回傳值型態, 連 void 也不行 如果加上回傳值型態 ( 含 void) 則不是建構函式, 如此就不會在物件實體產生時自動執行 (3) 沒有任何修飾字 (4) 建構函式只能被 new 運算子於產生物件實體時自動呼叫, 無法讓物件的一般函式自由呼叫 (5) 封裝等級一般宣告為 public 等級 如果宣告為 private 等級, 則只有其他建構函式可以呼叫它 無法被 new 自動呼叫 觀念範例 7-4 : 使用建構函式改寫範例 7-2, 使其成為建構函式以便自動進行成員變數的初始化 範例 7-4:ch7_04.java( 隨書光碟 myjava\ch07\ch7_04.java) 建構子 /* 檔名 :ch7_04.java 功能 : 建構函式 */ package myjava.ch07; import java.lang.*; public class ch7_04 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(1); // 自動呼叫建構函式 CMyClass Y = new CMyClass(2); // 自動呼叫建構函式 X.addVar(10); // 在 X 物件上, 執行 addvar 成員函式 System.out.print(" 物件 X\t"); X.showVar(); System.out.print(" 物件 Y\t"); Y.addVar(5); // 在 Y 物件上, 執行 addvar 成員函式 Y.showVar(); System.out.print(" 物件 Y\t"); Y.addVar(3); // 在 Y 物件上, 執行 addvar 成員函式 Y.showVar(); 74

38 7.6 建構子 : 46 建構子名稱需與類別名稱相同 class CMyClass public CMyClass(int i) 建構子 Var=i;... 同範例 7-2 的第 36~48 行... 執行結果 : 物件 X Var=11 物件 Y Var=7 物件 Y Var=10 範例說明 : 第 10 行, 宣告物件變數 X 並產生實體, 當實體產生時, 就會自動立刻執行該類別的建構函式, 也就是執行第 29~32 行程式 第 11 行亦同理 如果將第 11 行傳入的引數改為 1, 則執行結果同範例 建構子的多載 上一章所提到的多載功能不但可以應用於一般成員函式, 也可以應用於建構函式 程式可藉由定義多個不同參數 ( 或不同資料型態 ) 的建構函式, 提供物件實體初始化時更大的彈性 觀念範例 7-5 : 多載建構函式, 使得在物件實體產生時, 可以依照不同情況執行不同的建構函式 範例 7-5:ch7_05.java( 隨書光碟 myjava\ch07\ch7_05.java) 76

39 7.6.1 建構子的多載 /* 檔名 :ch7_05.java 功能 : 建構函式的多載 */ package myjava.ch07; import java.lang.*; public class ch7_05 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(); CMyClass Y = new CMyClass(5,40); CMyClass Z = new CMyClass(20.2,30.6); X.showVar(); Y.showVar(); Z.showVar(); class CMyClass public double VarA; private double VarB; 呼叫第 24 行的建構子 呼叫第 29 行的建構子 呼叫第 34 行的建構子 建構子的多載 public CMyClass() // 定義無參數的建構函式 VarA=10; VarB=10; public CMyClass(int a,int b) // 定義兩個整數參數的建構函式 VarA=a; VarB=a+b; public CMyClass(double a,double b) // 定義兩個浮點數參數的建構函式 VarA=a; VarB=a*b; public void showvar() System.out.println("VarA=" + VarA); System.out.println("VarB=" + VarB); 執行結果 : VarA=10.0 VarB=10.0 VarA=5.0 VarB=45.0 VarA=20.2 VarB=

40 7.6.1 建構子的多載 範例說明 : (1) 第 24~38 行是 3 個建構函式的定義, 其署名不相同, 符合多載的規定 並且其內的建構內容也可以不同 (2) 第 10 行產成 X 物件實體, 由於沒有引數, 所以會執行第 24~28 行的建構函式 第 11 行生成 Y 物件實體, 由於有 2 個 int 整數引數, 所以會執行第 29~33 行的建構函式 第 12 行生成 Z 物件實體, 由於有 2 個 double 浮點數引數, 所以會執行第 34~38 行的建構函式 預設的建構子 如果您未定義建構函式, 則 Java 編譯器會自動產生一個內建的預設建構函式 (Default Constructor) 到程式中, 函式內容為空, 也沒有參數, 格式如下 : public 類別名稱 () // 預設的建構函式 正因為有此預設的建構函式, 所以在之前的範例中, 有時我們並未定義建構函式, 但編譯仍不會出錯 但是如果您已經定義了一個以上的建構函式時,Java 編譯器便會認定您已經準備好所有的建構函式, 此時將不會再產生預設建構函式, 而若您沒有建立一個無參數的建構函式, 卻又於產生物件實體時不傳入引數, 則會發生錯誤, 請見以下的範例 80

41 7.6.2 預設的建構子 觀念範例 7-6 : 取消預設建構函式的注意事項範例 7-6:ch7_06.java( 隨書光碟 myjava\ch07\ch7_06.java) /* 檔名 :ch7_06.java 功能 : 預設的建構子 */ 執行結果 package myjava.ch07; import java.lang.*; public class ch7_06 // 主類別 VarA=5 VarB=45 public static void main(string args[]) CMyClass X = new CMyClass(5,40); // 實體產生有兩個整數引數 //CMyClass Y = new CMyClass(); X.showVar(); //Y.showVar(); 無法找到對應的建構子 預設的建構子 class CMyClass public int VarA; private int VarB; public CMyClass(int a,int b) // 定義兩個整數參數的建構函式 VarA=a; VarB=a+b; public void showvar() System.out.println("VarA=" + VarA); System.out.println("VarB=" + VarB); 範例說明 : 第 11 行的註解如果取消, 則會發生錯誤, 因為預設的建構函式並不會產生, 故找不到對應的建構函式可執行 所以在定義建構函式時, 應該先定義一個無參數的建構函式 ( 函式內容可以暫時為空 ), 以避免這樣的狀況 小試身手 7 1 依照範例 7 6 的說明, 將第 行的註解取消, 並加入無參數的建構函式 ( 函式內容為空 ), 使得可編譯並執行成功 82

42 7.6.3 回收物件實體 在 Java 中, 想要釋放物件實體, 只要將所有參考到該物件實體的物件變數都設為 null 或指向其他實體, 則 Java 的回收機制就會在一段時間後自動回收該物件實體的記憶體空間 而其他程式語言 ( 例如 C++) 則提供了 delete 與解構函式, 需要使用者手動關心物件釋放的後續動作 物件引數的傳參考值呼叫 在呼叫函式時, 引數也可以是物件 在前面的範例中, 我們曾經示範過傳遞字串物件 當時我們曾經提及, 傳遞字串物件, 事實上採用的是傳 參考值 呼叫 因為物件變數本身是一個參考而非實體 當我們要傳遞一個自行定義的類別所宣告的物件變數時, 同樣採用的是傳 參考值 呼叫, 因此, 呼叫端與被呼叫端可以共用一個物件實體 在下面這個範例中, 我們將傳遞物件, 並且將使用成員函式多載進行不同資料型態的加法 84

43 7.7 物件引數的傳參考值呼叫 觀念範例 7-7 : 使用多載設計成員函式, 並且接受引數為其他類別的物件 在本範例中, 我們將把加法函式擴充到二維向量的加法, 範例如右 : 範例 7-7:ch7_07.java( 隨書光碟 myjava\ch07\ch7_07.java ) 物件引數的傳參考值呼叫 /* 檔名 :ch7_07.java 功能 : 傳遞物件與接收物件 */ package myjava.ch07; import java.lang.*; 執行結果 public class ch7_07 // 主類別 Vector i=(20,40) Vector j=(15,45) public static void main(string args[]) Vector k=i+j=(35,85) CVector2 i = new CVector2(); i.set(20,40); CVector2 j = new CVector2(); j.set(15,45); CVector2 k; //k 是 CVector2 物件變數, 在第 16 行用來接收回傳值 CMyClass X = new CMyClass(); k=x.sum(i,j); System.out.println("Vector i=(" + i.x + "," + i.y + ")"); System.out.println("Vector j=(" + j.x + "," + j.y + ")"); System.out.println("Vector k=i+j=(" + k.x + "," + k.y + ")"); 86

44 class 物件引數的傳參考值呼叫 CMyClass public int sum(int a,int b) return a+b; public double sum(double a,double b) return a+b; public CVector2 sum(cvector2 a,cvector2 b)// 二維向量的加法成員函式 CVector2 tempvector = new CVector2(); tempvector.x=a.x+b.x; tempvector.y=a.y+b.y; return tempvector; class CVector2 // 二維向量類別 public int x,y; // 二維向量的兩項元素資料 public void set(int m,int n) // 用於設定二維向量的兩項元素資料 x=m; y=n; 物件引數的傳參考值呼叫 範例說明 : (1) 我們在第 43~51 行, 宣告了另一個類別 CVector2, 用來代表二維向量 並提供一個 set 成員函式在第 46~50 行 (2) 除了整數與浮點數的加法, 在第 34~40 行, 我們又增加了 CMyClass 的另一個成員函式 sum, 它接受的引數是兩個 CVector2 類別的物件, 並且回傳一個 CVector2 類別的物件, 它會做二維向量的加法, 並回傳二維向量 (3) 第 10~11 行, 宣告一個 CVector2 類別的物件 i 並產生實體, 且設定成員變數為 (20,40) (4) 第 12~13 行, 宣告一個 CVector2 類別的物件 j 並產生實體, 且設定成員變數為 (15,45) (5) 第 14 行, 宣告一個 CVector2 類別的物件變數 k (6) 第 15 行, 宣告一個 CMyClass 類別的物件 X 並產生實體 88

45 7.7 物件引數的傳參考值呼叫 (7) 第 16 行, 透過 X 物件的 sum 成員函式, 幫我們做二維向量的加法, 所以 k 向量 =(35,85) (8) 在第 16 行的函式呼叫,i 物件的參考傳送給對應的 a 物件參考, 故 i 與 a 實際上指向同一個物件實體 j 與 b 亦同理 (9) 在第 14 行時,k 是一個物件參考, 初始值為 null, 而第 16 行時, 由於第 39 行會回傳一個物件實體位址, 所以 k 儲存該位址後, 可以指向物件的實體 在上一個範例中, 雖然 i 與 a 指向同一個物件,j 與 b 指向同一個物件, 但依據的是傳 參考值 呼叫 對於 Java 的傳 參考值 呼叫, 每一年都會引起論壇的討論, 爭辯傳參考呼叫與傳參考值呼叫的差別 物件引數的傳參考值呼叫 傳參考呼叫 (Pass by reference) 一般而言, 指的是程式語言功能中的傳址呼叫 (Call by address) 其特色是被呼叫端的參數會影響呼叫端的引數, 如 C++ 與 C# 都提供此一功能 傳值呼叫 (Pass by value) 則是程式語言功能中的傳值呼叫 (Call by value) 其特色是被呼叫端的參數不會影響呼叫端的引數, 大多數的程式語言都提供了此一功能, 如 Java 由於傳址呼叫所能達到的效果, 在被呼叫端需要影響呼叫端兩個以上的變數時非常有用 ( 因為函式回傳值只能傳遞一個值 ), 因此程式語言必須提供傳址呼叫若未提供傳址呼叫, 則必須提供其他機制來達到同樣的效果而所謂其他機制, 則不可避免地仍需要傳遞一個記憶體位址才可能達到同樣的效果例如 C 語言就是透過傳指標呼叫 (Pass by pointer) 來達成此一效果 90

46 7.7 物件引數的傳參考值呼叫 Java 的傳 參考值 呼叫則與 C 語言的傳指標呼叫 (Pass by pointer) 類似它雖然也是透過引數傳遞一個位址給被呼叫端的參數, 但即便參數所保存的位址值 ( 參考值 ) 改變了, 也不會影響引數所保存的位址值 ( 參考值 ) 換句話說, 傳 參考值 呼叫仍屬於傳值呼叫 (Call by value) 的一種, 只不過這個值是一個參考罷了 所以傳參考呼叫與傳參考值呼叫是不同的兩種機制 因此, 在眾多的 Java 原文技術文件中, 都會提及,Java 只支援傳值呼叫, 這是因為傳 參考值 呼叫仍屬於傳值呼叫 (Call by value), 而不是傳址呼叫 (Call by address) 以上, 在上一章介紹 Java 傳遞陣列時, 我們已經說明過了, 下面這個範例, 將會證明 Java 在傳遞物件或陣列時, 採用的只是傳 參考值 呼叫, 而非傳參考呼叫 物件引數的傳參考值呼叫 假設 Java 提供了傳參考呼叫 ( 傳址呼叫 ), 我們可以很容易的製作一個 swap(i,j) 函式, 用以將 i,j 互相對調 以下, 我們嘗試製作一個 swap 函式將兩個引數 ( 物件參考 i, 物件參考 j) 對調看看 觀念範例 7-8 : 嘗試設計一個 swap 函式互換兩個物件參考 範例 7-8:ch7_08.java( 隨書光碟 myjava\ch07\ch7_08.java) 92

47 7.7 物件引數的傳參考值呼叫 /* 檔名 :ch7_08.java 功能 : 物件的傳參考值呼叫 */ package myjava.ch07; import java.lang.*; public class ch7_08 // 主類別 public static void main(string args[]) CVector2 i = new CVector2(); i.set(20,40); CVector2 j = new CVector2(); j.set(15,45); System.out.println("----- 原始 "); 執行結果 原始 Vector i=(20,40) Vector j=(15,45) swap 後 Vector i=(20,40) Vector j=(15,45) System.out.println("Vector i=(" + i.x + "," + i.y + ")"); System.out.println("Vector j=(" + j.x + "," + j.y + ")"); CMyClass X = new CMyClass(); X.swap(i,j); System.out.println("-----swap 後 "); System.out.println("Vector i=(" + i.x + "," + i.y + ")"); System.out.println("Vector j=(" + j.x + "," + j.y + ")"); 物件引數的傳參考值呼叫 class CMyClass public void swap(cvector2 a,cvector2 b) // 互換函式 CVector2 temp; temp=a; a=b; b=temp; class CVector2 // 二維向量類別 public int x,y; // 二維向量的兩項元素資料 public void set(int m,int n) // 用於設定二維向量的兩項元素資料 x=m; y=n; 範例說明 : (1) 從執行結果中, 我們發現對調失敗了, 為什麼會這樣呢? 我們以記憶體的變化來說明 94

48 7.7 物件引數的傳參考值呼叫 (2) 當第 10~17 行執行完畢時, 記憶體內容呈現下圖狀況,i 指向 3100 的物件實體,j 指向 3600 的物件實體 物件引數的傳參考值呼叫 (3) 第 18 行的 X.swap(i,j); 會把 i 與 j 的參考傳送給 a 與 b, 如下圖 然後開始執行第 28~33 行的程式 96

49 7.7 物件引數的傳參考值呼叫 (4) 第 29 行會配置一個可存放參考的記憶體給 temp, 第 30 行則會讓 a 的參考設定給 temp, 使得兩者都指向同一個物件 第 30 行執行完畢時, 結果如下圖 : 物件引數的傳參考值呼叫 (5) 第 31 行則會讓 b 的參考設定給 a, 使得兩者都指向同一個物件 第 31 行執行完畢時, 結果如下圖 : 98

50 7.7 物件引數的傳參考值呼叫 (6) 第 32 行則會讓 temp 的參考設定給 b, 使得兩者都指向同一個物件 第 32 行執行完畢時, 結果如下圖 :(a 與 b 的參考已經互換完成 ) 物件引數的傳參考值呼叫 (7) 第 33 行執行完畢時會返回函式呼叫處, 此時, 由於參數 a,b 及函式內的 temp 都屬於區域變數, 故會被釋放 故 a 與 b 的互換根本沒有意義, 因為 i 與 j 並沒有互換, 記憶體內容和執行函式呼叫前是完全相同的 所以印出的結果自然是沒有互換成功的結果 (8) 雖然我們互換失敗, 但確實在 swap 中, 若透過 a 或 b 或 temp 修改物件實體的變數內容的話, 則呼叫返回後, i 或 j 的物件實體內容也會被更動 但這並非傳統所謂的傳參考呼叫 (pass by reference), 頂多只能稱的上是傳參考值呼叫 (pass by value of reference) (9) 如果您熟悉 C++ 語言的話, 就會知道,C++ 語言支援傳參考呼叫, 一個類似功能的程式碼如下, 請注意其結果,i 與 j 的內容是被更動的 100

51 7.7 物件引數的傳參考值呼叫 /* 檔名 :ch7_08.cpp 功能 : 傳參考呼叫 */ #include <iostream> #include <stdlib.h> using namespace std; class CVector2 // 二維向量類別 public: int x,y; // 二維向量的兩項元素資料 public: void set(int m,int n) // 用於設定二維向量的兩項元素資料 Vector i=(15,45) Vector j=(20,40) x=m; y=n; ; 執行結果 原始 Vector i=(20,40) Vector j=(15,45) swap 後 class CMyClass public: void swap(cvector2 &a,cvector2 &b) // 互換函式, 傳參考呼叫 CVector2 temp; temp=a; a=b; b=temp; ; 物件引數的傳參考值呼叫 int main(char args[]) CVector2 i; i.set(20,40); CVector2 j; j.set(15,45); cout << "----- 原始 " << endl; // 列印 cout << "Vector i=(" << i.x << "," << i.y << ")" << endl; cout << "Vector j=(" << j.x << "," << j.y << ")" << endl; CMyClass X; X.swap(i,j); // 互換 i,j cout << "-----swap 後 " << endl; // 列印 cout << "Vector i=(" << i.x << "," << i.y << ")" << endl; cout << "Vector j=(" << j.x << "," << j.y << ")" << endl; system("pause"); return 0; (10) 不只 C++ 支援傳參考呼叫,C# 同樣也支援傳參考呼叫, 上述範例改寫為 C# 版本的程式碼如下, 請注意其結果,i 與 j 的內容是被更動的 102

52 7.7 物件引數的傳參考值呼叫 // 檔名 :ch7_08.cs 功能 : 傳參考呼叫 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 class Program static void Main(string[] args) CVector2 i = new CVector2(); i.set(20,40); CVector2 j = new CVector2(); j.set(15,45); Console.WriteLine("----- 原始 "); 執行結果 原始 Vector i=(20,40) Vector j=(15,45) swap 後 Vector i=(15,45) Vector j=(20,40) Console.WriteLine("Vector i=(" + i.x + "," + i.y + ")"); Console.WriteLine("Vector j=(" + j.x + "," + j.y + ")"); CMyClass X = new CMyClass(); X.swap(ref i, ref j); // 傳參考呼叫 Console.WriteLine("-----swap 後 "); Console.WriteLine("Vector i=(" + i.x + "," + i.y + ")"); Console.WriteLine("Vector j=(" + j.x + "," + j.y + ")"); Console.Read(); 物件引數的傳參考值呼叫 class CMyClass public void swap(ref CVector2 a, ref CVector2 b) // 傳參考呼叫 CVector2 temp; temp = a; a = b; b = temp; class CVector2 // 二維向量類別 public int x, y; // 二維向量的兩項元素資料 public void set(int m, int n) // 用於設定二維向量的兩項元素資料 x = m; y = n; 104

53 7.8 this 關鍵字 this 是一個特殊的關鍵字, 在撰寫程式時代表類別的本身, 在實際執行時, 則代表物件的本身 不過我們先暫時不討論 this 關鍵字, 而是思考另外一個問題, 即 當成員變數與區域變數同名 的問題 區域變數與成員變數同名 在前面曾經提及, 如果是類別內的敘述, 則使用類別內的成員時, 不用加上物件名稱 ( 例如範例 7-8 的第 行 ) 而如果在函式中定義了區域變數, 就有可能與成員變數同名, 此時, 取用該名稱的變數會是區域變數還是成員變數呢? 由於區域變數的宣告較靠近存取敘述, 因此取用的將是區域變數, 請見下列範例 觀念範例 7-9 : 區域變數與成員變數同名的探討 範例 7-9:ch7_09.java( 隨書光碟 myjava\ch07\ch7_09.java) 106

54 7.8.1 區域變數與成員變數同名 /* 檔名 :ch7_09.java 功能 : 區域變數與成員變數同名 */ package myjava.ch07; import java.lang.*; public class ch7_09 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(); X.show(); class CMyClass public int var=10; // 成員變數 public void show() int var=20; System.out.println("var=" + var); 執行結果 var=20 // 區域變數 將會取用到區域變數 var 區域變數與成員變數同名 範例說明 : 從執行結果中, 我們發現取用到的是區域變數 var, 而非成員變數 var, 那麼我們如果在 show() 函式內要取用成員變數 var 該怎麼辦呢? 此時必須搭配 this 關鍵字來取用 108

55 7.8.2 this 關鍵字的簡易使用法 this 關鍵字是一個非常特別的關鍵字 對於任何類別而言,this 就是代表著該類別本身, 當類別產生物件實體後, 則物件的 this 代表物件實體本身 因此, 如果要使得範例 7-9 能夠取用到成員變數, 可以透過 this 關鍵字來完成 觀念範例 7-10 : 改寫範例 7-9, 使得區域變數與成員變數都能夠被印出 範例 7-10:ch7_10.java( 隨書光碟 myjava\ch07\ch7_10.java) this 關鍵字的簡易使用法 /* 檔名 :ch7_10.java 功能 :this 關鍵字的簡易使用法 */ package myjava.ch07; import java.lang.*; public class ch7_10 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(); X.show(); class CMyClass public int var=10; // 成員變數 public void show() int var=20; // 區域變數 System.out.println(" 區域變數 var=" + var); System.out.println(" 成員變數 var=" + this.var); 執行結果 區域變數 var=20 成員變數 var=10 將會取用物件的 var 成員 110

56 7.8.2 this 關鍵字的簡易使用法 範例說明 : 在這個範例中, 我們發現如果區域變數與成員變數不同名的話, 使用與不使用 this 關鍵字並沒有差別 那麼 this 關鍵字的功用是否僅止於此呢? 事實上並不是的, 不過我們應該先深入探討 this 的真正涵意以及實作上的變化, 然後再來討論 this 的用途 深入探討 this 關鍵字 在前面我們已經說明 this 可於實作時期 ( 程式執行時 ), 當作物件本身來使用 因此上述範例的 this, 代表的就是物件 X 如果在其他類別中 ( 例如主類別 main 函式中 ), 我們要取用物件 X 的 var 變數值, 可透過 X.var 來達成, 而在 X 的方法中, 則可以透過 this.var 來達成, 因為 this 就是 X 而 this 是 X 的什麼呢? 從 X.var 中的 X 可以得知,X 在 Java 中扮演的是一個物件的參考, 故 this 實際上是代表物件本身的參考 假設 X 的實體位址為 3100, 則 this 也是 3100, 所以對於 JVM 而言, 不論遇到 X.var 或 this.var, 它看到的都是存取位於位址 3100 之物件實體中的成員變數 var 112

57 7.8.3 深入探討 this 關鍵字 事實上, 不論我們在程式中是否出現 this 關鍵字,Java 編譯器在編譯類別時, 都會自動加上隱含的參考變數 this, 並且 this 並不算是類別的成員, 而且只能在類別中使用 this 變數值設定的時機, 是在遇到 new 類別名稱 () 時, 由於 new 代表產生類別的物件實體, 故會有一個實體的開始位址, 在 Java 中, 我們將該位址稱為物件的參考 (reference), 而當 new 指令執行完畢時,this 變數就被設定為該物件的參考 而在範例 7-10 中, 第 10 行執行完畢時, 不僅 X 被設定為物件的參考,this 也被設定為物件的參考 深入探討 this 關鍵字 事實上,this() 代表的是呼叫該類別的建構函式, 不過這樣的語法只能出現在建構函式的第一行 因此, 當建構函式想要呼叫另一個建構函式以進行初始化的分工時, 就可以藉由 this() 來完成 除此之外,this 既然是編譯時期會加入的隱含變數, 故在產生物件實體時, 它也是物件實體的一部分 而在之前的圖示中, 我們有時候會看到物件實體內包含了成員函式, 但它未包含完整的成員函式內容, 事實上, 它的作用只是用來呼叫程式段的成員函式實作 114

58 7.8.3 深入探討 this 關鍵字 而由於每一個物件都可能去執行程式段的成員函式, 故對於程式段的成員函式而言, 它必須知道是哪一個物件要求執行它, 以便於當它要取用成員變數時, 知道要取用哪一個物件的成員變數 如下圖示意 : 深入探討 this 關鍵字 正因為程式段的成員函式需要知道是哪一個物件呼叫它, 故 Java 的做法是, 在編譯時期, 編譯器會對所有的成員函式都加上一個隱含的 final 參數 this, 參數的型別是類別本身, 因此,this 參數是一個參考, 而該 this 參數將會在函式呼叫時, 被設定為引數物件的參考值, 故而呼叫時, 會變成是將物件本身當作引數傳遞過去, 使得在呼叫成員函式時, 函式得以判斷是哪一個物件呼叫它, 並且取用到正確的成員變數 而正由於 this 是被宣告為 final 參數, 故只有在呼叫時能被設定, 之後就不能再被設定了 因此上圖應該修改為下圖才是完整的圖示 116

59 7.8.3 深入探討 this 關鍵字 圖 7-9 this 的作用 深入探討 this 關鍵字 在上圖中, 如果是 X 的 show 函式要求執行程式段的 show 函式, 則會傳入 X 的參考, 也就是 3100, 因此, 程式段的 show 函式在取用 this.var 變數時, 知道要取用處於位址 3100 之物件實體的成員變數 var 現在我們算是徹底瞭解了 this, 以下, 我們透過一個範例來觀察,this 的內容究竟為何? 觀念範例 7-11 : 觀察 this 變數內容, 以求得物件實體的所在位址 範例 7-11:ch7_11.java( 隨書光碟 myjava\ch07\ch7_11.java) 118

60 7.8.3 深入探討 this 關鍵字 /* 檔名 :ch7_12.java 功能 :this 的內容 */ package myjava.ch07; import java.lang.*; public class ch7_11 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(); CMyClass Y = new CMyClass(); System.out.print("X 物件實體所在位址 ="); X.show_this(); System.out.print("Y 物件實體所在位址 ="); Y.show_this(); class CMyClass public int var=10; // 成員變數 public void show_this() System.out.println(this); 執行時,this 代表物件的實體位址 深入探討 this 關鍵字 執行結果 : X 物件實體所在位址 =myjava.ch07.cmyclass@5fa6fb3e Y 物件實體所在位址 =myjava.ch07.cmyclass@4bb8d481 範例說明 : 從執行結果中, 我們可以得知 X 物件的實體所在位址為 5fa6fb3e, 而 Y 物件的實體所在位址為 4bb8d

61 7.8.4 this 關鍵字的使用時機 總結上述的介紹, 我們可以將 this 關鍵字的使用時機整理如下 : 1. 取得物件實體的參考 : 如同範例 區別成員變數與區域變數 : 如同範例 用以作為物件本身, 例如進行物件的比較 : 請見範例 在建構函式內, 藉以呼叫其他的建構函式 : 使用的是 this( 引數串 ) 格式, 語法如下, 請見範例 this 關鍵字的使用時機 使用 this( 引數串 ) 呼叫建構函式語法 : [ 封裝等級 ] 建構函式名稱 ( 參數串 ) // 建構函式名稱就是類別名稱 this( 引數串 ); // 必須是建構函式的第一個敘述 建構函式的其餘內容 122

62 7.8.4 this 關鍵字的使用時機 觀念及實用範例 7-12 : 藉由 this( 引數串 ) 呼叫其他的建構函式 範例 7-12:ch7_12.java( 隨書光碟 myjava\ch07\ch7_12.java) /* 檔名 :ch7_12.java 功能 : 在建構函式中使用 this( 引數列 ) */ package myjava.ch07; import java.lang.*; public class ch7_12 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(3); // 實體產生時呼叫第 22 行的建構子 CMyClass Y = new CMyClass(5,40);// 實體產生時呼叫第 27 行的建構子 X.showVar(); Y.showVar(); class CMyClass public int VarA; private int VarB; 執行結果 VarA=1 VarB=3 VarA=200 VarB= this 關鍵字的使用時機 public CMyClass() // 良好的習慣是補上一個沒有參數的建構函式 public CMyClass(int i) // 定義一個整數參數的建構函式 VarA=1; VarB=i; public CMyClass(int a,int b) // 定義兩個整數參數的建構函式 this(b); // 呼叫第 22 行的建構函式, 藉以設定 VarB VarA=a*b; public void showvar() System.out.println("VarA=" + VarA); System.out.println("VarB=" + VarB); 範例說明 : 在第 29 行, 將設定 VarB 的工作交給第 22 行的建構函式完成, 雖然它也會設定 VarA, 但第 30 行會重新計算 VarA 的值 使用 this( 引數串 ) 呼叫建構函式, 必須在建構函式中才能使用, 並且必須是第一個敘述 124

63 7.8.4 this 關鍵字的使用時機 觀念及實用範例 7-13 : 兩物件的比較 範例 7-13:ch7_13.java( 隨書光碟 myjava\ch07\ch7_13.java) /* 檔名 :ch7_13.java 功能 : 物件的比較 */ package myjava.ch07; import java.lang.*; public class ch7_13 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(5); CMyClass Y = new CMyClass(5); CMyClass Z = X; System.out.print(" 物件 X 與物件 Y "); X.compare2Obj(Y); System.out.print(" 物件 X 與物件 Z "); X.compare2Obj(Z); this 關鍵字的使用時機 class CMyClass private int Var; public CMyClass() public CMyClass(int i) Var=i; public void compare2obj(cmyclass Obj) if(this==obj) System.out.println(" 兩物件相等 "); else System.out.println(" 兩物件不相等 "); // 良好的習慣是補上一個沒有參數的建構函式 // 一個整數參數的建構函式 執行結果 : 物件 X 與物件 Y 兩物件不相等物件 X 與物件 Z 兩物件相等 126

64 7.8.4 this 關鍵字的使用時機 範例說明 : (1) 在第 31 行進行兩物件的比較, 其中 this 將會是物件本身的參考, 例如第 行, 由於是由 X 執行該函式, 故 this 代表 X 而 Obj 則是接收傳入的引數, 例如第 14 行的呼叫, 則 Obj 代表 Y, 第 16 行的呼叫, 則 Obj 代表 Z (2) 從執行結果中, 我們可以發現物件的比較事實上是參考的比較, 而非實體內容的比較 這是因為不論是物件名稱或 this, 代表的都是一個參考, 而相等比較 == 代表的是比較兩個參考值是否相同 所以如果兩個參考值不同 ( 指向不同的實體 ), 即使所指向的實體 內容 完全相同, 也不會被判斷為相等 物件陣列 物件也可以存放於陣列中, 只不過存放的將會是物件的參考因此, 要使用物件陣列, 至少需要使用兩次以上的 new 運算子 語法如下 : 類別名稱陣列名稱 [] = new 類別名稱 [ 物件數量 ]; for(int i=0;i< 陣列名稱.length;i++) 陣列名稱 [i]=new 類別名稱 ( 引數串列 ); // 為每一個陣列元素產生物件實體 語法說明 (1) 第一行是宣告一維物件陣列, 並產生陣列實體 同樣的, 它可以分解為兩行如下 類別名稱陣列名稱 []; 陣列名稱 = new 類別名稱 [ 物件數量 ]; // 宣告陣列名稱 // 產生陣列實體 128

65 7.9 物件陣列 (2) 由於每一個陣列元素代表每一個物件的參考, 所以我們可以透過迴圈逐次產生各個物件實體 如果您想要呼叫的建構函式不同, 則可以將迴圈展開, 手動逐個產生各個物件實體, 如下範例語法 : 陣列名稱 [0]=new 類別名稱 ( 引數串列 ); 陣列名稱 [1]=new 類別名稱 ( 引數串列 ); 陣列名稱 [2]=new 類別名稱 ( 引數串列 ); : : : 物件陣列 範例 1 宣告一個包含 10 個字串物件的陣列 strarr, 初始內容為空 String strarr[] = new String[10]; for(int i=0;i<strarr.length;i++) strarr[i]=new String(); // 為每一個陣列元素產生物件實體 說明 strarr 包含 10 個陣列元素, 每一個陣列元素都是字串物件的參考, 在迴圈中, 我們則為這些物件參考產生物件實體 130

66 7.9 物件陣列 範例 2 宣告一個包含 7 個字串物件的陣列 strarr, 初始內容為各星期的英文單字 String strarr[] = new String[7]; strarr[0]=new String("Sunday"); strarr[1]=new String("Monday"); strarr[2]=new String("Tuesday"); strarr[3]=new String("Wendesday"); strarr[4]=new String("Thursday"); strarr[5]=new String("Friday"); strarr[6]=new String("Saturday"); // 為陣列元素 strarr[0] 產生物件實體 // 為陣列元素 strarr[1] 產生物件實體 // 為陣列元素 strarr[2] 產生物件實體 // 為陣列元素 strarr[3] 產生物件實體 // 為陣列元素 strarr[4] 產生物件實體 // 為陣列元素 strarr[5] 產生物件實體 // 為陣列元素 strarr[6] 產生物件實體 說明 由於要藉由建構函式建置不同的字串內容, 故將迴圈展開手動來設定引數 物件陣列 觀念範例 7-14 : 建立一個物件陣列, 並透過引數設定, 觀察建構函式的執行狀況 範例 7-14:ch7_14.java( 隨書光碟 myjava\ch07\ch7_14.java) /* 檔名 :ch7_14.java 功能 : 物件陣列與建構函式 */ package myjava.ch07; import java.lang.*; public class ch7_14 // 主類別 public static void main(string args[]) CMyClass X[] = new CMyClass[3]; System.out.println(" "); for(int i=0;i<x.length;i++) X[i] = new CMyClass(); CMyClass Y[] = new CMyClass[3]; System.out.println(" "); for(int i=0;i<y.length;i++) Y[i] = new CMyClass(i+10); 132

67 7.9 物件陣列 class CMyClass public int VarA; private int VarB; public CMyClass() // 無參數的建構函式 System.out.println(" 無參數的建構函式執行中 "); public CMyClass(int i) System.out.println(" 有參數的建構函式執行中, 參數為 " + i); 執行結果 : 無參數的建構函式執行中無參數的建構函式執行中無參數的建構函式執行中 有參數的建構函式執行中, 參數為 10 有參數的建構函式執行中, 參數為 11 有參數的建構函式執行中, 參數為 物件陣列 範例說明 : 利用第 行的列印, 我們可以得知, 物件的建構函式會等到實際產生物件實體時才進行, 而不會在產生物件陣列實體時進行, 因為物件陣列內的元素只是物件的參考而已 傳遞物件陣列我們時常會有需要將物件陣列傳遞給某個函式, 進行更進一步的應用 傳遞物件陣列和傳遞一般陣列的語法差不多, 只不過是將原始資料型態改為類別名稱而已, 請見下列範例 134

68 7.9 物件陣列 觀念範例 7-15 : 觀察物件陣列中, 每個元素的參考值 藉以了解物件實體在記憶體的配置情形 範例 7-15:ch7_15.java( 隨書光碟 myjava\ch07\ch7_15.java) /* 檔名 :ch7_15.java 功能 : 傳遞物件陣列與物件配置情形 */ package myjava.ch07; import java.lang.*; public class ch7_15 // 主類別 public static void main(string args[]) CMyClass X[] = new CMyClass[5]; for(int i=0;i<x.length;i++) X[i] = new CMyClass(); COtherClass Obj = new COtherClass(); Obj.show(X); 物件陣列 class COtherClass public void show(cmyclass X[]) for(int i=0;i<x.length;i++) System.out.println(" 物件 X[" + i + "] 實體的位址在 " + X[i]); class CMyClass public int VarA; private int VarB; 執行結果 : 物件 X[0] 實體的位址在 myjava.ch07.cmyclass@3238c403 物件 X[1] 實體的位址在 myjava.ch07.cmyclass@2cccbab7 物件 X[2] 實體的位址在 myjava.ch07.cmyclass@34f65b5b 物件 X[3] 實體的位址在 myjava.ch07.cmyclass@19e7ce87 物件 X[4] 實體的位址在 myjava.ch07.cmyclass@41a80e5a 136

69 7.9 物件陣列 範例說明 : (1) 第 14 行 Obj 物件呼叫 show 函式時, 將物件陣列當作引數傳入函式中 (2) 在 show 函式中, 我們列印 X[i] 的內容, 會列印出每個物件的參考位址, 您可以發現, 雖然陣列元素 X[0]~X[5] 會位於連續的記憶體位址, 但實際的物件實體並不一定會位於連續的記憶體位址 參考圖示如下 : 類別變數與類別方法 回顧定義類別的語法, 我們可以發現, 在宣告成員變數或成員函式時, 可以指定其 [ 修飾字 ] 其中, 對於成員變數而言, 我們可以將修飾字指定為 static, final, transient, volatile 等等, 或其組合, 不過 final 與 volatile 不能合用 對於成員函式而言, 我們可以將修飾字指定為 static, final, abstract, native, synchronized 等等, 或其組合, 但 abstract 則不能與其他修飾字合用 這些修飾字對於成員變數或成員函式將產生不同的效果 在本節中, 我們要介紹的只有 static 修飾字使用 static 修飾字定義的成員變數稱為類別變數 (class variable) 使用 static 修飾字定義的成員函式稱為類別方法 (class method) 因此, 我們可以將語法修改如下 : 138

70 7.10 類別變數與類別方法 定義 類別變數 與 類別方法 語法 [ 封裝等級 ] [ 修飾字 ] class 類別名稱 [extends 父類別 ] [implements 介面 ] [ 封裝等級 ] static [ 其他修飾字 ] 資料型態 field 名稱 ; // 宣告類別變數 : : [ 封裝等級 ] static [ 其他修飾字 ] 回傳值型態 method 名稱 ( 參數串 ) // 定義類別方法 method 的內容 : : 說明 : (1) 由於 static 仍可以和其他的修飾字合用, 故我們保留了 [ 其他修飾字 ] 語法欄位 不過, 如果使用在成員函式宣告, 則 static 不可與 abstract 合用 (2) 在類別方法內, 不可以存取實體變數 類別變數與類別方法 變數的種類 在第二章時, 我們曾經提及 Java 的變數一共分為四大類如下, 在之前的章節中, 我們已經學習過區域變數與參數, 而事實上, 我們也使用過實體變數與類別變數, 本節要深入探討的是實體變數與類別變數的區別 (1) 實體變數 (Instance Variables): 見 節 (2) 類別變數 (Class Variables): 見 節 (3) 區域變數 (Local Variables): 在函式內宣告的變數, 生命週期侷限於函式執行時, 視野也侷限於函式內 (4) 參數 (Parameters): 函式定義第一行所宣告的變數 用於呼叫函式時, 接收呼叫者傳遞之資料 140

71 實體變數與實體方法 我們在類別內宣告成員變數與成員函式時, 如果沒有加上 static 修飾字, 則可以將這些成員變數與成員函式稱為實體變數 (Instance Variables) 與實體方法 (Instance Methods) 顧名思意, 實體變數與實體方法代表一定要有實體, 這些變數與方法才可使用 當我們宣告一個物件變數並透過 new 產生實體後 ( 或透過設定運算子指向某一個實體後 ), 就可以在外部程式透過 物件名稱. 成員變數 或 物件名稱. 成員函式 () 來存取呼叫 public 等級的成員變數及成員函式 實體變數與實體方法 必須透過物件名稱才能夠完成存取呼叫 是實體變數與實體方法的特色 在前面的圖示中, 我們了解到, 當每一個物件實體使用 new 產生時, 在記憶體中, 針對每一個物件實體, 會配置實體變數所需要的記憶體空間而對於實體方法也會配置一個記憶體空間, 記載著程式段的函式名稱與引數, 並且 this 也會自動變成參數之一 換句話說, 如果沒有使用 new 產生物件實體的話, 則在記憶體中, 並不存在實體變數與實體方法 例如下列範例發生錯誤的原因, 是因為 X 並沒有物件實體, 所以無法存取實體變數, 也無法執行實體方法 如果將 CMyClass X; 修改為 CMyClass X=new CMyClass(); 則語法就沒有錯誤 142

72 實體變數與實體方法 雖然 Java 是一個純物件導向語言, 但並非每一個變數與方法都必須藉由物件才能執行 例如在表 3-8 所介紹的 tostring(), 就不需要透過物件即可執行, 因為它屬於類別方法 public class test // 主類別 public static void main(string args[]) CMyClass X; X.Var=3; // 錯誤, 因為 X 的參考為 null X.show(); // 錯誤,X 並未參考到實體 class CMyClass public int Var; public CMyClass() // 定義無參數的建構函式 public void show() System.out.println("Hello"); 類別變數與類別方法 雖然 Java 是一個物件導向語言, 但實質上, 它是以類別為基礎 (class-based) 來撰寫程式在 Java 中, 所有的變數與方法都必須隸屬於某一個類別, 而無法像 C++ 定義出不屬於任何類別的變數與函式 至於 Java 的物件, 只是類別生成出的一個實體, 它仍規範在類別的基礎之上 由於 Java 是以類別為基礎的程式語言, 因此它允許我們在不產生物件的狀況下, 使用變數與方法, 但僅侷限於類別變數與類別方法 144

73 類別變數與類別方法 類別變數 (Class Variables) 與類別方法 (Class Methods) 合稱類別成員 (Class Members) 在宣告類別成員時, 必須將修飾字宣告為 static, 如同前面的語法格式, 而使用時, 由於沒有物件名稱, 故外部程式必須指名類別名稱才能夠執行, 如下語法 : 外部程式存取 類別變數 與執行 類別方法 語法 : 類別名稱. 類別變數 ; 類別名稱. 類別方法 ( 引數串 ); 類別變數與類別方法 說明 (1) 在類別內部的程式, 不需要指名類別名稱即可取用這些類別變數或執行類別方法 (2) 即使透過 static 宣告為 類別變數 與 類別方法, 當該類別生成物件時, 仍可以當作物件的 變數 與 方法 來存取, 存取語法與實體變數或方法完全相同, 只不過, 這些由該類別生成的物件, 必須共用類別變數, 同時, 呼叫類別方法也是由同一個記憶體內容指出被呼叫端位於的程式段 146

74 類別變數與類別方法 當編譯器完成編譯動作並開始執行時 於載入類別的同時, 如果發現類別中包含類別變數與類別方法, 就會立刻配置這些類別成員 ( 不必等到物件實體產生時 ) 而對於實體變數與實體方法, 則必須等到執行 new 敘述而配置物件實體時才會配置 以下, 我們透過一個範例來觀察類別變數與類別方法的使用方式與記憶體配置 觀念範例 7-16 : 存取類別變數與呼叫類別方法 範例 7-16:ch7_16.java( 隨書光碟 myjava\ch07\ch7_16.java) 類別變數與類別方法 /* 檔名 :ch7_16.java 功能 : 類別變數與類別方法 */ package myjava.ch07; import java.lang.*; public class ch7_16 // 主類別 public int Var; public static int svar; public void show(string str) System.out.println(str + "'s Var=" + Var); System.out.println("ch7_16 class svar=" + svar); public static void add() // 類別方法 //Var++; svar++; 錯誤, 因為類別方法內不可以存取實體變數 執行結果 X's Var=3 ch7_16 class svar=7 Y's Var=10 ch7_16 class svar=7 148

75 類別變數與類別方法 public static void main(string[] args) ch7_16 X = new ch7_16(); ch7_16 Y = new ch7_16(); X.Var=3; Y.Var=10; X.sVar=5; // 使用物件存取類別變數 X.add(); // 使用物件執行類別方法 Y.add(); // 使用物件執行類別方法 X.show("X"); Y.show("Y"); 範例說明 : (1) 這個範例只有一個類別 ch7_16 ch7_16 類別內包含一個實體變數 Var, 一個實體方法 show (2)ch7_16 類別內包含一個類別變數 svar, 兩個類別方法 main,add 在 add 中, 不可以存取 Var, 因為它是類別方法, 不可以直接存取實體變數 類別變數與類別方法 (3)X,Y 是 ch7_16 類別的兩個物件實體的參考 (4) 在第 26~32 行, 我們透過 X,Y( 物件名稱 ) 存取實體變數及類別變數, 呼叫實體方法及類別方法, 語法都相同 (5) 由執行結果中, 可以發現, 不論是由 X 物件或 Y 物件呼叫 show 函式, 印出的 svar 都相同, 因為 svar 是 共用的變數 在第 28 行首先透過 X 將 svar 設定為 5, 然後在第 29 行將它加 1 第 30 行則是透過 Y, 將 svar 又加 1 因此最後印出的為 7 (6) 本範例執行完畢時的記憶體圖示如下, 其中, main,add,svar 是所有該類別之生成物件所共用的, 故它只有一份拷貝, 並且該份拷貝在類別被載入記憶體時, 就被配置了 ( 並非等到 new 敘述執行時 ) 150

76 類別變數與類別方法 圖 7-10 實體變數 ( 及方法 ) 與類別變數 ( 及方法 ) 類別變數與類別方法 觀念範例 7-17 : 透過類別名稱存取類別變數與呼叫類別方法 範例 7-17:ch7_17.java( 隨書光碟 myjava\ch07\ch7_17.java) /* 檔名 :ch7_17.java 功能 : 類別名稱存取類別成員 */ package myjava.ch07; import java.lang.*; 執行結果 修改前 Var=10 public class ch7_17 // 主類別 修改後 Var=20 使用物件呼叫時 Var=20 public static void main(string args[]) CMyClass.show(" 修改前 "); // 執行類別方法 CMyClass.Var=20; // 存取類別變數 CMyClass.show(" 修改後 "); // 執行類別方法 CMyClass X = new CMyClass(); X.show(" 使用物件呼叫時 "); 152

77 類別變數與類別方法 class CMyClass public static int Var=10; public static void show(string str) System.out.println(str+ "Var=" + Var); 範例說明 : (1) 這個範例有兩個類別 其中 CMyClass 只有一個類別變數與一個類別方法 (2) 在 ch7_17 類別中的 main 函式如果要存取 CMyClass 的類別變數, 並不需要產生物件, 只要註明類別名稱即可, 如第 11 行 呼叫類別方法, 也不需要產生物件, 只要註明類別名稱即可, 如第 行 (3) 即使透過物件呼叫類別方法, 您也可以由執行結果看出物件 X 存取到的 Var, 仍是在類別一開始就被配置的 Var 變數, 也就是類別變數仍被共用, 而非專屬於某一個物件 類別方法的限制 在前面我們曾經提及, 類別方法由於被宣告為 static, 所以只能存取被宣告為 static 的類別變數, 同時, 它也只能直接呼叫被宣告為 static 的類別方法 由於 main 函式已經被宣告為 static, 所以也只能呼叫類別方法, 故我們在前一章介紹函式時, 設計的函式都加上了 static 修飾字 除了上述限制之外, 在類別方法內也不能使用 this 關鍵字因為 this 在執行時代表的是一個物件的參考, 而由於類別方法可以直接由類別名稱來呼叫執行, 因此呼叫當時並沒有所謂的物件實體, 當然也就不會有物件實體的參考, 故而在類別方法使用 this 關鍵字是不合法的 154

78 類別成員的初始化 建構子在物件實體產生時, 自動被 new 敘述呼叫, 進行物件實體的初始化設定可是類別成員在類別被載入時就會被配置記憶體, 如果想要將類別變數初始化, 除了設定初值之外, 就必須透過 static 區段來設計初始化動作, 如下語法 : static 敘述群 ( 可進行類別變數初始化 ) 語法說明 : 上面這個 static 區段, 必須放在類別內, 它不屬於任何方法, 並且會在類別變數配置之後自動開始執行 類別成員的初始化 觀念範例 7-18 : 改寫範例 7-17, 透過 static 區段初始化類別變數 範例 7-18:ch7_18.java( 隨書光碟 myjava\ch07\ch7_18.java) /* 檔名 :ch7_18.java 功能 :static 區段 */ package myjava.ch07; import java.lang.*; public class ch7_18 // 主類別 public static void main(string args[]) CMyClass.show(" 修改前 "); // 執行類別方法 CMyClass.Var=20; // 存取類別變數 CMyClass.show(" 修改後 "); // 執行類別方法 CMyClass X = new CMyClass(); X.show(" 使用物件呼叫時 "); 156

79 類別成員的初始化 class CMyClass public static int Var; public static void show(string str) System.out.println(str+ "Var=" + Var); static Var=100; System.out.println(" 類別變數 Var 初始化完畢 " + Var); show(" 初始化之後 "); 執行結果 : 類別變數 Var 初始化完畢 100 初始化之後 Var=100 修改前 Var=100 修改後 Var=20 使用物件呼叫時 Var= 類別成員的初始化 範例說明 : 從執行結果中, 可以發現,static 是最早被執行的程式區塊 ( 比 main 函式還要早 ), 因為 JVM 會先載入 ch7_18 與 CMyClass 類別後才執行主類別的 main 函式, 而當載入 CMyClass 類別後, 就會自動執行 static 區段的敘述 158

80 類別內的無名區段 在上一小節中, 我們發現以 static 為名的區段會在類別載入後自動開始執行 事實上,Java 允許我們在類別內定義一個無名的區段, 而該區段會在物件實體產生時, 自動被執行, 並且執行時機比建構子還要早 不過, 由於利用建構子對物件進行初始化是比較正統的做法, 因此建議盡量少用這樣的語法 觀念範例 7-19 : 類別內無名區段的執行時機範例 7-19:ch7_19.java( 隨書光碟 myjava\ch07\ch7_19.java) 類別內的無名區段 /* 檔名 :ch7_19.java 功能 : 類別內的無名區段 */ package myjava.ch07; import java.lang.*; public class ch7_19 // 主類別 public static void main(string args[]) CMyClass X = new CMyClass(); X.show(" 使用物件呼叫時 "); class CMyClass public int Var; public CMyClass() Var=10; System.out.println(" 建構函式執行中 "); show(" 建構函式執行完畢時 "); 160

81 類別內的無名區段 public void show(string str) System.out.println(str+ "Var=" + Var); Var=100; System.out.println(" 無名區塊執行中 "); show(" 無名區塊執行完畢時 "); 無名區段 執行結果 : 無名區塊執行中無名區塊執行完畢時 Var=100 建構函式執行中建構函式執行完畢時 Var=10 使用物件呼叫時 Var= 類別內的無名區段 範例說明 : 由執行結果中可以發現, 無名區段會在建構函式開始前就先被執行 而如果您將第 10 行的 new 敘述去除, 例如改寫為 CMyClass X;( 當然第 11 行必須刪除 ) 則無名區段也不會被執行, 因為物件實體尚未產生 Coding 注意事項 不論是無名區段或 static 區段, 都可以有多個, 其執行順序為由上而下 162

82 7.11 本章回顧 在本章中, 我們簡單介紹了物件導向程式設計的三大特性, 包含封裝性 繼承性與多型性 我們也初次嘗試透過一般類別 ( 非主類別 ) 與物件來設計程式, 在這兩個主題之下, 我們學習到了下列相關技術 : (1) 類別是 Java 物件導向程式最基本的單元, 是產生同一類物件的基礎, 類別其實是一種使用者自定的資料型態, 並且 Java 的類別成員可以定義為多種資料存取等級如下, 不寫 : 類別庫 (package) 等級 public: 公用等級 private: 私用等級 protected: 保護等級 本章回顧 (2) 公用資料變數與函式允許由類別以外的外部程式存取或執行, 但私用資料變數與成員函式只允許被同一個類別中的函式存取或執行 至於保護等級則留待繼承一章再作介紹 類別庫等級則允許同屬一個類別庫的類別存取或執行 Java 藉由資料等級達到了物件導向的 封裝性 特性 (3) 物件是類別的實體, 使用類別資料型態宣告物件時, 並未產生物件實體, 必須透過 new 運算子才會產生物件實體 (4) 物件存取其變數與方法的語法如下 : 物件. 成員資料物件. 成員函式 ( 引數列 ) (5) 當物件實體透過 new 生成後, 會馬上自動執行建構函式 ( 建構子 ), 而建構函式的名稱與類別名稱相同, 並允許多載 164

83 7.11 本章回顧 (6) 若未定義任何建構函式, 則 Java 編譯器會自動產生一個內建的預設建構函式 (Default Constructor), 其函式內容為空, 也沒有參數 但若定義了一個以上的建構函式時, 則不會產生預設建構函式 (7) 多載 (overload) 允許重複定義多個同名的成員函式或建構函式, 只要署名不同即可, 使得程式設計具有更大的彈性 Java 藉由多載 ( 及其他技術 ) 達到了物件導向的 多型性 特性 (8) 當物件實體不被任何物件變數參考時,Java 的回收機制就會在一段時間後自動回收該物件實體的記憶體空間 (9) 函式呼叫時, 若引數為物件, 則採用的是傳參考值呼叫, 因為物件變數本身是一個參考 傳參考值呼叫仍屬於傳值呼叫的一種, 只不過傳遞的值是一個參考 (10) 對於任何類別而言,this 在實際執行時, 代表類別生成的物件本身 ( 也就是一個物件參考 ) 本章回顧 (11) 在類別內以 static 宣告成員變數或成員函式時, 代表宣告類別變數與類別方法 此時不需要產生物件就可以執行類別方法, 而所有該類別生成的物件也將共用類別變數 在類別方法中不能使用 this 關鍵字 (12) 在類別內宣告成員變數或成員函式時, 如果沒有加上 static 修飾字, 則稱為實體變數 (Instance Variables) 與實體方法 (Instance Methods) 顧名思義, 它必須在產生物件實體後才能夠被存取與呼叫 延伸學習 : 巢狀類別 巢狀類別指的是類別內又定義了另一個類別, 由於巢狀類別的語法較為複雜, 因此在本章先不介紹, 但是由於視窗程式常會使用內部類別 ( 也屬於巢狀類別 ) 實作一個事件傾聽者, 因此, 我們會在視窗程式設計單元介紹巢狀類別 166

84 本章結束 Q&A 討論時間 167