Microsoft PowerPoint - SE7ch11.ppt

Transcription

1 第十一章類別庫 課前指引 package 可以想像為類別庫, 它是收納與管理類別的地方, 一般以目錄為單位 在本章中, 我們將介紹何謂 package, 為何需要 package, 以及如何使用 package 來管理我們撰寫的程式 除此之外, 本章還將介紹幾種常使用的類別, 包含字串類別及數學類別等等 章節大綱 11.1 為何需要 package 11.2 定義 package 11.3 切割檔案 11.5 匯入類別庫的所有類別 11.6 常用的類別庫 -java.lang 11.7 變數及方法的封裝等級 11.4 package 的階層關係 11.8 本章回顧 備註 : 可依進度點選小節

2 11.1 為何需要 package 當類別或介面的數量很龐大時, 為了避免名稱衝突, 因此通常採用 namespace 的方式來解決 所謂 namespace, 代表的是在一個空間中, 不會有相同名稱出現 在 Java 中, 它採用的是 package 來管理類別, 而 package 以目錄為單位 由於目錄在檔案系統中的路徑必定唯一, 因此, 只要相同 package 中沒有同名的類別就不會有名稱衝突的問題 為何需要 package 舉例來說,JDK7 提供的類別庫有很多, 例如 java.applet java.awt java.awt.color java.awt.font java.io java.lang java.lang.ref java.math 等等 您可以在 JDK7 的文件網頁中查到所有的類別庫, 網址如下 : 4

3 11.1 為何需要 package 類別庫列表 單一類別的說明 類別列表 圖 11-1 Java 的說明文件網頁 為何需要 package 註 您也可以於 Oracle 的 Java 官方網站下載完整的類別說明檔, 下載網址如下 : html 下載後解壓縮, 就可以在下列路徑中找到 index.html 檔, 開啟後則如圖 11-1 \Java\SE7\jdk-7-fcs-bin-b147-apidocs-27_jun_2011\docs\api\index.html 下載 圖 11-2 Java 的說明文件下載網頁 6

4 11.1 為何需要 package 在說明網頁的左上方框架中, 包含了所有的 package 當您點下某個 package, 則左下方框架就會出現屬於該 package 的類別 再選擇其中一個類別後就可以在右方框架中查閱到該類別的成員說明 明顯地, 我們可以看出, 有些類別庫的名稱前半部相同, 例如 java.awt java.awt.color, 您可以將之視為父類別庫與子類別庫事實上, 如果您下載了 Java 原始碼 OpenJDK), 則可以看到存放的位置即為父目錄與子目錄的關係 ( 如圖 11-3), 也就是 package 的完整名稱恰與路徑相同 ( 以. 作為層次之分 ), 故各類別庫必定是唯一的 為何需要 package 子類別庫 父類別庫 父類別庫的類別 圖 11-3 JDK7 類別庫原始檔的階層關係 8

5 11.1 為何需要 package 延伸學習 :OpenJDK 這是 JDK7 的開放原始碼版本, 您可以於下列網址中下載 OpenJDK 來觀看原始碼中類別與目錄的對應關係 在每個 package 目錄中包含了許多的 Java 檔與子目錄當我們將 package 當作是類別庫時, 這些 Java 檔內包含的類別就是屬於該 package 而子目錄則可以視為該 package 的子類別庫 為何需要 package 類別名稱相同常常是無法完全避免的, 但當以類別所屬的類別庫作為 namespace 時, 將不再會有名稱相同的問題, 因為類別庫所屬路徑是唯一的 舉例來說,JDK7 提供的類別中有三個類別名稱皆為 Timer, 但由於分屬不同的 package, 因此完整的類別名稱 ( 含 package 名稱 ) 則不會相同, 分別如下 : javax.swing.timer // 隸屬於 javax.swing 類別庫的 Timer 類別 javax.management.timer.timer // 隸屬於 javax.management.timer 類別庫的 Timer 類別 java.util.timer // 隸屬於 java.util 類別庫的 Timer 類別 10

6 11.2 定義 package Java 規定 package 名稱必須與目錄名稱一致, 這是為了使用目錄唯一性作為 namespace 的解決策略 而如果要將某個類別宣告為隸屬於某個 package, 則必須在該程式檔中加入 package 敘述, 語法格式如下 : package 類別庫名稱 ; 定義 package 語法說明 : (1) 在 Java 類別原始碼的 Byte.java 中, 宣告了 package java.lang;, 因此 Byte.java 內的所有類別 ( 如主類別 Byte), 都屬於 java.lang 類別庫 (2) 在第十章範例中, 每個 Java 原始檔案都宣告了 package myjava.ch10;, 因此這些檔案內的類別都屬於 myjava.ch10 類別庫, 也與檔案存放的目錄路徑一致 (3) 當類別經過編譯為 class 檔案後, 若類別庫不包含完整路徑, 則必須設定環境變數 CLASSPATH 才能執行 如果未設定 CLASSPATH, 則必須於執行時加入參數 -cp 指定類別的路徑 而類別的路徑與原始檔中註明之類別庫兩者合併則為完整的檔案路徑 詳見範例

7 11.2 定義 package 範例 11-1a : 路徑與類別的關係假設我們並未設定 CLASSPATH, 而範例 11-1 的程式碼如下, 並且檔案位於 C:\myJava\ch11 目錄 範例 11-1a,b,c :( 三個範例共用 ch11_01.java 檔 ) ch11_01.java( 隨書光碟 myjava\ch11\ch11_01.java) 定義 package /* 檔名 :ch11_01.java 功能 : 類別庫 */ package ch11; import java.lang.*; 宣告本檔案內的所有類別所屬之類別庫 public class ch11_01 // 主類別 public static void main(string args[]) CCircle obj = new CCircle(5.0); obj.showarea(); class CCircle protected double area; protected double radius; protected final double pi=3.14; public CCircle(double i) radius=i; public void showarea() area=radius*radius*pi; System.out.println("Area=" + area); 14

8 11.2 定義 package 則我們可以在 C:\myJava\ 下執行下列編譯指令 : C:\myJava>javac ch11\ch11_01.java 因為我們所在路徑為 C:\myJava, 配合指定路徑 ch11\ch11_01.java, 則可以組合成完整路徑 C:\myJava\ch11\ch11_01.java, 故可以編譯成功 編譯完成後, 在 ch11 下會出現兩個類別檔 分別是 ch11_01.class 與 CCircle.class 定義 package 由於在程式中, 我們註明了 package ch11;, 因此這兩個類別檔都屬於 ch11 類別庫, 並且必須放在 ch11 目錄下執行 我們可以在 C:\myJava\ 下執行下列指令 : C:\myJava>java ch11.ch11_01 Area=78.5 我們無法將上述的 ch11_01 改為 CCircle, 因為它並沒有 main method 16

9 11.2 定義 package 範例 11-1b : 指定路徑的編譯與執行假設我們位於 C:\ 或其他位置, 要完成上述範例, 則可以如下編譯 : C:\>javac C:\myJava\ch11\ch11_01.java 編譯完成後, 同樣在 ch11 下會出現兩個類別檔, 分別是 ch11_01.class 與 CCircle.class 同樣地由於在程式中, 我們註明了 package ch11;, 因此這兩個類別檔都屬於 ch11 類別庫, 並且必須放在 ch11 目錄下執行 如果我們位於 C:\ 或其他位置, 則可以執行下列指令以執行 ch11_01 類別檔 : C:\>java -cp C:\myJava; ch11.ch11_01 Area=78.5 上述的 -cp 代表要設定類別庫路徑 定義 package 但我們不可透過下列指令執行 ch11_01 類別檔 : 使用本章之前的執行方式是行不通的 C:\>java myjava.ch11.ch11_01 Exception in thread "main" java.lang.noclassdeffounderror: myjava/ch11/ch11_01 (wrong name: ch11/ch11_01) at java.lang.classloader.defineclass1(native Method) at java.lang.classloader.defineclass(unknown Source) at java.security.secureclassloader.defineclass(unknown Source) at java.net.urlclassloader.defineclass(unknown Source) at java.net.urlclassloader.access$100(unknown Source) at java.net.urlclassloader$1.run(unknown Source) at java.net.urlclassloader$1.run(unknown Source) at java.security.accesscontroller.doprivileged(native Method) at java.net.urlclassloader.findclass(unknown Source) at java.lang.classloader.loadclass(unknown Source) at sun.misc.launcher$appclassloader.loadclass(unknown Source) at java.lang.classloader.loadclass(unknown Source) at sun.launcher.launcherhelper.checkandloadmain(unknown Source) 18

10 11.2 定義 package 之所以不可以如此執行的原因在於, 我們在程式第 3 行指定的 package 為 ch11, 而非 myjava.ch11, 若修改為 myjava.ch11, 則可以透過上述指令執行 ch11_01 類別檔 換句話說, 我們在程式中, 只指定了程式的 ch11_01 與 CCircle 類別屬於 ch11 類別庫, 但並未指定它們屬於 myjava.ch11 類別庫 故 myjava 對於程式而言, 只不過是檔案的存放路徑, 與類別並無關係, 所以應該要用 -cp 來指示類別庫的路徑 定義 package 範例 11-1c : 設定 CLASSPATH, 編譯並執行程式為了避免使用 -cp 來指定類別庫路徑, 我們也可以在系統中設定環境變數 CLASSPATH 來取代 -cp 的設定, 方式如下 : Step1: 1 按下滑鼠右鍵 Windows 7 於功能表中, 在電腦上按下 滑鼠右鍵, 執行快顯功能表的 內容 指令 Windows XP, 在我的電腦上按下 滑鼠右鍵, 執行快顯功能表的 內容 指令 2 執行 20

11 11.2 定義 package Step2: Windows 7 按下進階系統設定 Windows XP 直接前往下一步驟 按下 定義 package Step3: 切換到進階頁籤, 按下 環境變數 鈕 按下 22

12 11.2 定義 package Step4: 新增環境變數, 按下 新增 鈕 按下 定義 package 5: 輸入變數名稱為 CLASSPATH, 變數值為路徑 C:\myJava, 加結尾分號, 最後按下 確定 鈕 3. 按下 1. 輸入 2. 輸入 24

13 11.2 定義 package Step6: 回到原對話方塊時, 可以發現多出了一筆剛剛設定的環境變數 最後按下 確定 鈕, 關閉對話方塊即可 新增成功 按下 定義 package 如上設定完成後, 請關閉原有的 Dos 對話方塊後, 重新開啟新的 Dos 對話方塊 接著我們可以如同前面範例的方式先編譯 ch11_01.java 檔, 使之在 ch11 目錄下產生兩個類別檔 C:\>javac C:\myJava\ch11\ch11_01.java 由於我們已完成上述的 CLASSPATH 環境變數設定, 因此我們可以在 C:\ 之下輸入下列指令執行 ch11_01 類別檔 : C:\>java ch11.ch11_01 Area=

14 11.3 切割檔案 在本章之前的所有範例, 我們的範例程式檔.java 都只有一個, 但編譯後會依據檔案內的類別數量編譯出相對應的.class 類別檔 事實上, 我們也可以將各個類別分別寫在不同的.java 程式檔中, 以便分類管理或將各類別交由不同的人員來開發, 以加快程式發展時程 切割檔案 觀念範例 11-2 : 將各類別切為各檔案 範例 11-2:CCircle.java( 隨書光碟 myjava\ch11\ccircle.java) // 檔名 :CCircle.java // 未宣告 package 未宣告 package 視為屬於 沒有名稱的 package class CCircle protected double area; protected double radius; protected final double pi=3.14; public CCircle(double i) radius=i; public void showarea() area=radius*radius*pi; System.out.println("Area=" + area); 28

15 11.3 切割檔案 ch11_02.java( 隨書光碟 myjava\ch11\ch11_02.java) /* 檔名 :ch11_02.java 功能 : 以類別切割檔案 */ 未宣告 package 視為屬於 沒有 // 未宣告 package 名稱的 package public class ch11_02 // 主類別 public static void main(string args[]) CCircle obj = new CCircle(5.0); obj.showarea(); 切割檔案 執行結果 : C:\myJava\ch11>javac CCircle.java C:\myJava\ch11>javac ch11_02.java C:\myJava\ch11>java ch11_02 Area=78.5 編譯 CCircle.java 編譯 ch11_02.java 執行 ch11_02.class 範例說明 : 請特別注意, 這個範例的 Java 原始檔中並沒有宣告檔案內的類別屬於哪一個類別庫, 此時 Java 將之視為屬於 沒有名稱的 package, 而若要能夠正確執行, 本範例的兩個.class 檔必須放在同一個目錄下才可以執行, 但目錄名稱則不限 您可以試著把本範例的 ch11_02.class 與 CCircle.class 同時搬移到其他目錄來執行, 結果也不會有錯誤 30

16 宣告 package 為了避免類別名稱相同, 我們最好在各 java 檔中使用 package 宣告所屬的類別庫 若各 java 檔宣告了相同的類別庫名稱, 則分屬於各 java 檔內的類別也就同屬一個 package 請見下列範例 : 宣告 package 觀念範例 11-3 : 將不同檔案的類別宣告為同一個類別庫 範例 11-3:CRect.java( 隨書光碟 myjava\ch11\pack1\crect.java) // 檔名 : 位於 pack1\crect.java package pack1; // 本檔案內的類別屬於 pack1 類別庫 class CRect protected double area; protected double len,width; CRect 類別屬於 pack1 類別庫 public CRect(double i,double j) len=i; width=j; public void showarea() area=len*width; System.out.println("Area=" + area); 32

17 宣告 package ch11_03.java( 隨書光碟 myjava\ch11\pack1\ch11_03.java) /* 檔名 : 位於 pack1\ch11_03.java 功能 : 將不同檔案的類別宣告為同一個類別庫 */ package pack1; public class ch11_03 // 本檔案內的類別屬於 pack1 類別庫 ch11_03 類別屬於 pack1 類別庫 public static void main(string args[]) CRect obj = new CRect(5.0,3.0); obj.showarea(); 宣告 package 範例說明 : 我們在兩個程式檔中, 都宣告了 package pack1;, 使得 ch11_03 與 CRect 類別都屬於 pack1 類別庫並且應該要將兩個類別檔 ch11_03.class 與 CRect.class 放置於 pack1 目錄下執行 如下圖示意 : 檔案系統 其編譯及執行過程如下 ( 請特別注意我們原來所在之目錄以及各檔案所在目錄 ): 34

18 宣告 package 執行結果 : 編譯 pack1 子目錄的 CRect.java C:\myJava\ch11>javac pack1\crect.java C:\myJava\ch11>javac pack1\ch11_03.java 編譯 pack1 子目錄的 ch11_03.java C:\myJava\ch11>java pack1.ch11_03 Area=15.0 執行 pack1 類別庫的 ch11_03.class 範例說明 : 由於本範例的 CRect 類別宣告時, 並未加上封裝等級, 因此, 代表的是它採用類別庫封裝等級, 故只要是和它相同類別庫的程式都可以取用它, 而 ch11_03 與 CRect 皆為 pack1 類別庫, 所以可以取用它 使用不同 package 的類別 如果我們將各類別宣告了不同的 package ( 在不同檔案中使用 package 宣告 ), 則欲使用其他 package 的類別, 需要遵守下列兩項規則 : (1) 只能取用其他類別庫被宣告為 public 的類別 (2) 使用該類別時應該要將其類別庫名稱也明確指定, 格式為 類別庫名稱. 類別名稱 或使用 import 將類別匯入, 語法如 import 類別庫名稱. 類別名稱 ; 36

19 使用不同 package 的類別 觀念範例 11-4 : 使用其他類別庫的類別 範例 11-4: CRect.java( 隨書光碟 myjava\ch11\pack2a\crect.java) // 檔名 : 位於 pack2a\crect.java package pack2a; // 本檔案內的類別屬於 pack2a 類別庫 public class CRect protected double area; protected double len,width; 宣告為 public 才可以讓其他類別庫使用 public CRect(double i,double j) len=i; width=j; public void showarea() area=len*width; System.out.println("Area=" + area); 使用不同 package 的類別 ch11_04.java( 隨書光碟 myjava\ch11\pack2b\ch11_04.java) /* 檔名 : 位於 pack2b\ch11_04.java 功能 : 使用其他類別庫的類別 */ package pack2b; // 本檔案內的類別屬於 pack2b 類別庫 public class ch11_04 // 主類別應使用完整類別名稱 ( 包含 類別庫名稱 ) public static void main(string args[]) pack2a.crect obj = new pack2a.crect(5.0,3.0); obj.showarea(); 38

20 使用不同 package 的類別 範例說明 : 我們在兩個程式檔中, 宣告了不同的類別庫, 因此兩個.class 類別檔應該分別位於 pack2a 與 pack2b 目錄, 而為了要讓 CRect 類別能夠被其他類別庫的類別使用, 因此在 CRect.java 的第 4 行宣告了封裝等級為 public, 並且在取用時, 採用了 類別庫名稱. 類別名稱 的方式 ( ch11_04.java 的第 9 行 ) 本範例示意圖如下 : 檔案系統 使用不同 package 的類別 其編譯及執行過程如下 ( 請特別注意我們原來所在之目錄以及各檔案所在目錄 ): 執行結果 編譯 pack2a 子目錄的 CRect.java C:\myJava\ch11>javac pack2a\crect.java C:\myJava\ch11>javac pack2b\ch11_04.java 編譯 pack2b 子目錄的 ch11_04.java C:\myJava\ch11>java pack2b.ch11_04 Area=15.0 執行 pack2b 類別庫的 ch11_04.class 範例說明 : 請注意, 如果本範例的 CRect 類別宣告時未加上封裝等級, 則在編譯 ch11_04.java 會出現封裝等級不符的錯誤 40

21 使用不同 package 的類別 觀念範例 11-5 : 透過 import 匯入類別 範例 11-5:CRect.java( 隨書光碟 myjava\ch11\pack3a\crect.java) // 檔名 : 位於 pack3a\crect.java package pack3a; // 本檔案內的類別屬於 pack3a 類別庫 public class CRect // 宣告為 public 才可以讓其他類別庫使用 protected double area; protected double len,width; public CRect(double i,double j) len=i; width=j; public void showarea() area=len*width; System.out.println("Area=" + area); 宣告為 public 才可以讓其他類別庫使用 使用不同 package 的類別 ch11_05.java( 隨書光碟 myjava\ch11\pack3b\ch11_05.java) /* 檔名 : 位於 pack3b\ch11_05.java 功能 : 使用其他類別庫的類別 */ package pack3b; import pack3a.crect; // 本檔案內的類別屬於 pack3b 類別庫 // 匯入類別 public class ch11_05 // 主類別 public static void main(string args[]) CRect obj = new CRect(5.0,3.0); obj.showarea(); 已經匯入類別, 所以不必包含類別庫名稱 42

22 使用不同 package 的類別 範例說明 : 和上一個範例類似, 本範例的兩個類別分屬不同的類別庫, 只不過, 這次我們在 ch11_05 中, 先匯入了 CRect 類別 ( 第 5 行 ), 故可以在第 11 行直接取用該類別, 當然前提仍是該類別必須被宣告為 public 等級 (CRect.java 的第 4 行 ) 其編譯及執行過程如下 ( 請特別注意我們原來所在之目錄以及各檔案所在目錄 ): 執行結果 : C:\myJava\ch11>javac pack3a\crect.java C:\myJava\ch11>javac pack3b\ch11_05.java C:\myJava\ch11>java pack3b.ch11_05 Area= 使用不同 package 的類別 範例說明 : 請注意, 如果本範例的 CRect 類別宣告時未加上封裝等級, 則在編譯 ch11_05.java 仍會出現封裝等級不符的錯誤 這代表 import 只是匯入類別, 而非修改類別所屬的類別庫 44

23 封裝修飾字對 package 的影響 本章加入了 package 的討論, 因此, 我們將進一步討論封裝修飾字對於類別的影響 首先, 封裝修飾字可以使用於類別內的成員 ( 如成員方法 建構子 成員變數 ), 也可以使用於整個類別, 但規定則有所不同, 如下列表格整理 封裝修飾字對 package 的影響 修飾字 使用於整個類別 使用於類別內的成員 沒有修飾 類別只能被同一 成員只能被同一 package 的程式存取 字 package 的類別使 public 用 類別可以被不同 package 的類別使用 ( 但需匯入或指名類別庫名稱 ) 若所屬類別被宣告為 public, 則成員可被不同 package 的程式存取 若所屬類別非宣告為 public, 則成員只能被同一 package 程式存取 private 不合法 成員只能在類別內被存取 protected 不合法 若所屬類別被宣告為 public, 則成員除了可在同一類別庫內被存取外, 也可被不同 package 的子類別存取 ( 見範例 11-15) 若所屬類別非宣告為 public, 則成員只能被同一 package 的子類別存取 ( 見範例 11-6) 表 11-1 封裝修飾字對於類別的影響 46

24 封裝修飾字對 package 的影響 說明 : 在類別前的修飾字只能有 public 或完全不寫 當同時討論類別與成員的修飾字時, 只有成員修飾字為 public 與 protected 時比較複雜, 說明如下 : (1) 當成員修飾字為 public 時, 原本應該對於成員毫無限制 故限制應由類別的修飾字決定, 也就是只分為是否可被其他 package 的程式存取 (2) 當成員修飾字為 protected 時, 且類別並未被宣告為 public, 則其他 package 的類別根本無法使用它, 但若類別宣告為 public, 則其他 package 的類別可以透過繼承使用到該成員 請見下列範例 : 封裝修飾字對 package 的影響 觀念範例 11-6 : 類別封裝對繼承的影響 範例 11-6:CShape.java( 隨書光碟 myjava\ch11\pack4a\cshape.java) // 檔名 : 位於 pack4a\cshape.java package pack4a; // 本檔案內的類別屬於 pack4a 類別庫 public class CShape protected double area; 請刪除 public, 再試著編譯一次 48

25 封裝修飾字對 package 的影響 CRect.java( 隨書光碟 myjava\ch11\pack4b\crect.java) /// 檔名 : 位於 pack4b\crect.java package pack4b; // 本檔案內的類別屬於 pack4b 類別庫 public class CRect extends pack4a.cshape public 才可以讓其他類別 protected double len,width; 庫使用 public CRect(double i,double j) len=i; width=j; public void showarea() 可存取 area area=len*width; System.out.println("Area=" + area); 封裝修飾字對 package 的影響 ch11_06.java( 隨書光碟 myjava\ch11\pack4c\ch11_06.java) /* 檔名 : 位於 pack4c\ch11_06.java 功能 : 封裝對於繼承的影響 */ package pack4c; import pack4b.crect; // 本檔案內的類別屬於 pack4c 類別庫 // 匯入類別 public class ch11_06 // 主類別 public static void main(string args[]) CRect obj = new CRect(5.0,3.0); obj.showarea(); 50

26 封裝修飾字對 package 的影響 執行結果 : C:\myJava\ch11>javac pack4a\cshape.java C:\myJava\ch11>javac pack4b\crect.java C:\myJava\ch11>javac pack4c\ch11_06.java C:\myJava\ch11>java pack4c.ch11_06 Area=15.0 範例說明 : (1) 隸屬於 pack4a 的 CShape 被宣告為 public, 故隸屬 pack4b 的 CRect 類別可以繼承它, 但仍須指明類別庫名稱 ( 或採用 import 方式 ), 如同 CRect.java 的第 4 行 並且在 CRect.java 內也可以使用父類別 CShape 的 protected 成員 area (2) 若將 CShape.java 第 4 行的 public 刪除, 則在編譯 CShape.java 時不會有錯誤, 但在編譯 CRect.java 時將會出現錯誤, 因為無法繼承 CShape public 類別的唯一性 Java 規定, 每一個 Java 原始檔中, 只能有一個 public 類別這樣的用意是讓分工更為明確, 在沒有繼承關係的狀況下,Java 希望每一個公開出來的類別獨立編寫為一個程式檔, 這是很合理的, 因為這些類別間並無特殊關係存在 即使在有繼承關係的狀況下, 若您要開發的是類別庫, 筆者仍建議將各類別分別獨立為一個原始檔, 但願意給他人 ( 其他 package) 使用的類別, 應宣告為 public 類別 若僅願意開放給他人使用但不希望他人繼承, 則應該宣告為 public final 類別 52

27 public 類別的唯一性 假設目前有四個類別 A,B,C,D,C,D 皆繼承自 B,B 繼承自 A 假設類別 A 是一個很單純的類別, 並由類別 B 繼承後進一步發展, 而類別 C 與類別 D 則為發展完整的類別 您可能希望將類別 C 與類別 D 公開出來給他人 ( 其他 package) 使用但不讓他人繼承, 此時請將類別 C 與類別 D 宣告為 public final 類別 而類別 A 與類別 B 由於發展不完整, 因此希望他人可繼承使用, 則只需要宣告為 public 類別 public 類別的唯一性 總之, 當您發展類別庫時, 若將每一個類別都獨立為一個原始檔, 則您只需要考慮這個類別是否應該 公開給他人使用, 以及是否應該 公開給他人繼承使用 即可 因為您開發類別庫時, 通常使用的是同一個類別庫名稱, 故是否公開對於繼承並無影響 ie 類別不公開, 則宣告為非 public( 也就是不寫, 內定為 package 等級 ) ie 類別公開但不可繼承, 則宣告為 public final ie 類別公開也可繼承, 則宣告為 public 54

28 11.4 package 的階層關係 若 package 較多時, 除了可以將 package 以非階層關係分開之外, 也可以將 package 以階層關係分為子類別庫 (subpackage) 通常會分為子類別庫都是因為類別庫間有階層關係, 例如 java.awt 為視窗程式設計類別, 而其下有子類別庫 java.awt.color, java.awt.font 等等 由於子類別庫在名稱中, 已經記載了父類別庫, 因此程式檔在目錄的配置上, 也必須放置於父類別所在目錄的子目錄 package 的階層關係 而宣告子類別庫的語法如下 : package 類別庫名稱. 子類別庫名稱 ; 說明 : 當遇到更多層的類別庫時, 只需要增加. 來區隔即可 當然在目錄的配置上, 也必須具備更深層的目錄階層 56

29 11.4 package 的階層關係 觀念範例 11-7 : 子類別庫的練習 範例中, CCircle 與 CRect 所屬類別庫皆為 CShape 所屬類別庫的子類別庫 範例 11-7:CShape.java( 隨書光碟 myjava\ch11\pack5a\cshape.java) // 檔名 : 位於 pack5a\cshape.java package pack5a; // 本檔案內的類別屬於 pack5a 類別庫 public class CShape protected double area; package 的階層關係 CCircle.java( 隨書光碟 myjava\ch11\pack5a\subpacka\ccircle.java) // 檔名 : 位於 pack5a\subpacka\ccircle.java package pack5a.subpacka; public class CCircle extends pack5a.cshape protected double radius; protected final double pi=3.14; public CCircle(double i) radius=i; public void showarea() area=radius*radius*3.14; System.out.println("Circle Area=" + area); 本檔案內的類別屬於 subpacka 子類別庫 58

30 11.4 package 的階層關係 CRect.java( 隨書光碟 myjava\ch11\pack5a\subpackb\crect.java) / 檔名 : 位於 pack5a\subpackb\crect.java package pack5a.subpackb; public class CRect extends pack5a.cshape protected double len,width; public CRect(double i,double j) len=i; width=j; public void showarea() area=len*width; System.out.println("Rect Area=" + area); 本檔案內的類別屬於 subpackb 子類別庫 package 的階層關係 ch11_07.java( 隨書光碟 myjava\ch11\pack5b\ch11_07.java) /* 檔名 : 位於 pack5b\ch11_07.java 功能 : 子類別庫 */ package pack5b; import pack5a.subpacka.ccircle; import pack5a.subpackb.crect; // 本檔案內的類別屬於 pack5b 類別庫 // 匯入類別庫 // 匯入類別庫 public class ch11_07 // 主類別 public static void main(string args[]) CCircle obj1 = new CCircle(5.0); obj1.showarea(); CRect obj2 = new CRect(5.0,3.0); obj2.showarea(); 60

31 11.4 package 的階層關係 執行結果 : C:\myJava\ch11>javac pack5a\cshape.java C:\myJava\ch11>javac pack5a\subpacka\ccircle.java C:\myJava\ch11>javac pack5a\subpackb\crect.java C:\myJava\ch11>javac pack5b\ch11_07.java C:\myJava\ch11>java pack5b.ch11_07 Circle Area=78.5 Rect Area=15.0 範例說明 : (1) 本範例宣告子類別庫時, 將父類別庫也記載在內, 所以在匯入子類別庫時, 也需要將父類別庫明確記載 package 的階層關係 (2) 本範例目錄與類別庫的階層如下圖所示 檔案系統 62

32 11.5 匯入類別庫的所有類別 將類別使用類別庫分門別類有助於發展大型程式, 不過如果某一個類別庫包含眾多類別時, 要將之一一匯入似乎顯得很麻煩, 所幸,Java 允許我們一次匯入類別庫的所有類別, 其語法如下 : import 類別庫名稱.*; 匯入類別庫的所有類別 說明 使用 * 代表要匯入屬於該類別庫的所有類別, 但不包含子類別庫的類別 ( 並不包含匯入子類別庫 ) 換句話說, 在該目錄下的所有檔案 ( 不包含子目錄 ) 中, 所有被宣告為 public 的類別都可以使用 例如您可以將範例 11-5 的 ch11_05.java 第 5 行修改為 import pack3a.*;, 同樣可以匯入 CRect 類別 64

33 11.5 匯入類別庫的所有類別 匯入的類別名稱衝突 使用 * 代表類別庫的所有類別似乎很方便, 不過當您大量使用這種方式匯入類別時, 可能會發生類別名稱衝突的現象 例如您匯入了 javax.swing.* 與 java.util.*, 則在程式中指定 Timer 類別時, 編譯器便無法得知, 您想要使用的是 javax.swing.timer 類別還是 java.util.timer 類別 此時, 您有兩個方式可以解決這個問題 第一個方式是在使用類別時, 同時提供完整的 package 名稱, 也就是以 類別庫名稱. 類別名稱 來使用類別 第二種方式, 則是重新獨立匯入要使用的特定類別, 請見範例 匯入類別庫的所有類別 觀念範例 11-8 : 匯入類別庫的所有類別 範例 11-8:ch11_08.java( 隨書光碟 myjava\ch11\ch11_08.java) /* 檔名 :ch11_08.java 功能 : 類別名稱相同 - 特別匯入類別 */ package ch11; import java.lang.*; import javax.swing.*; import java.util.*; import java.util.timer; // 內含 Timer 類別 // 內含 Timer 類別 // 指定要使用 java.util.timer 類別 public class ch11_08 // 主類別 public static void main(string args[]) Timer obj = new Timer(); System.out.println(obj.toString()); obj.cancel(); 這裡的 Timer 類別指的是 java.util.timer 66

34 11.5 匯入類別庫的所有類別 執行結果 : C:\myJava>javac ch11\ch11_08.java C:\myJava>java ch11.ch11_08 java.util.timer@65ddcac5 範例說明 : (1) 第 5 行匯入 javax.swing 類別庫的所有類別, 第 6 行匯入 java.util 類別庫的所有類別 由於這兩個類別庫都有 Timer 類別, 故在第 7 行重新指定要使用 java.util.timer 類別 (2) 由執行結果可看出,obj 是 java.util.timer 類別的物件 (3) 若在本範例第 8 行也透過 import javax.swing.timer; 指定匯入另一個 Timer 類別, 則編譯時就會出現錯誤 這是編譯器為了明確判斷程式中使用的 Timer 類別是屬於哪一個類別庫, 故不允許在匯入單一類別時,import 兩次相同類別名稱的類別 匯入類別庫的所有類別 小試身手 11 1 請在範例 11 8 的第 8 行加入 import javax.swing.timer;, 然後重新編譯, 看看會獲得什麼結果? 自動 import 的類別 由於使用非使用者自行開發的類別, 在 Java 中幾乎是不可避免的 ( 例如所有的類別皆繼承自 Object 類別 ), 故即使未透過 import 指定匯入類別,Java 仍會自動匯入下列三個類別庫的類別 : 1 java.lang 類別庫 : 在之前的很多程式中, 我們都採用了 import java.lang.*; 匯入該類別庫的所有類別, 事實上, 即使去除該行,Java 仍會自動匯入該類別庫的所有類別 68

35 11.5 匯入類別庫的所有類別 2 預設的類別庫 : 預設的類別庫即之前所提及的 沒有名稱的類別庫 3 該類別所屬的類別庫 : 若該類別宣告為 pack1 類別庫, 則 Java 會自動匯入 pack1 的所有類別, 若該類別沒有宣告類別庫, 則如同 2 之所述,Java 仍會匯入與該類別同樣的類別庫 ( 即沒有名稱的類別庫 ) 中的類別 常用的類別庫 -java.lang 在特殊用途的程式中, 我們常常會使用 Java 提供的特定類別庫, 例如開發網路程式, 通常會大量使用 java.net 類別庫的類別 而對於一般非特定用途的程式, 則可能常使用到的類別庫為 java.lang ( 內定自動載入類別庫 ) 我們將於本節中介紹 java.lang 類別庫中最常使用的 wapper class String class StringBuffer class 及 Math class 70

36 wapper class wapper class 在 節中, 我們曾經介紹過 Java 的各種資料型態都有其對應的內建類別, 這些類別都隸屬於 java.lang 類別庫, 故不須透過 import 匯入就可以使用, 事實上, 這些類別的正式名稱為 wapper class, 共有 8 個類別, 如表 11-2 所列 而在 節中, 我們只簡單介紹了其中的轉型函式, 這些轉型函式都屬於 static methods, 故可以在不產生物件的狀況下使用, 其轉換函式請查閱表 wapper class 原始資料型態 byte short int long char boolean float double wapper class Byte Short Integer Long Character Boolean Float Double 表 11-2 原始資料型態對應之內建類別 72

37 wapper class wapper class 又稱為包裹類別, 在物件導向的程式設計中, 我們應該盡可能使用類別型態的變數, 也就是物件變數來設計程式, 雖然 Java 提供了原始資料型態, 但我們也可以透過包裹類別使得一些基本資料被包裝為物件 只不過如此做將會多佔用一些記憶體空間, 因為物件變數需要存放記憶體位址, 物件實體也需要存放一些方法的程式進入點 而使用 wapper class 宣告的變數稱為包裹型別 (wapper type) wapper class 裝箱 (boxing) 與拆箱 (unboxing) 當我們要使用 wapper class 建立物件來存放資料時, 必須注意其建構子的參數要求 以下, 我們以 Integer 類別作為範例來加以說明, 其餘的 wapper class 亦大同小異, 請讀者自行參閱 JDK 的說明文件 Integer 類別的建構子透過多載機制, 可以有下列兩種格式 : Integer(int value) Integer(String s) 74

38 wapper class 語法說明 : 若您採用的是第一種格式建立物件, 則 value 將是物件的內容, 它是一個整數資料型態 如果採用的是第二種格式, 則它必須能夠正確以 10 進制轉換為整數, 否則將會發生 NumberFormatException 的例外 下列是兩個透過建構子產生 Integer 物件的範例 Integer myint1 = new Integer(15); Integer myint2 = new Integer("18"); 上述的動作稱之為裝箱 (boxing), 亦即原本我們只打算宣告兩個整數變數, 但我們卻使用 Integer 類別的物件來存放這兩個整數變數, 這好比將整數變數放進了物件的箱子中 也就是說, 建構子執行時相當於裝箱的動作 wapper class 請注意,myInt1 與 myint2 都是一個物件參考, 故它不應該直接被使用來作為加減乘除的運算元 ( 在 JDK1.4 之前 ) 要取得物件內所存放的整數值必須透過 intvalue 函式來完成 至於其他各類 wapper class 取出資料的函式名稱上也大多是 原始資料型態名稱 +Value, 例如 doublevalue 而取出資料的動作則稱為拆箱 (unboxing) 76

39 wapper class 除了取出原本與資料相同的原始資料型態之外, 如果您觀察 JDK 說明文件, 就可以發現 Integer 類別也提供了 doublevalue 函式, 因此, 如果您需要將資料轉型為 double 型態, 則不必再透過轉型, 只要在取出資料時, 使用 doublevalue 函式取出即可 例如上述範例若執行 myint1.intvalue(); 則取出值為 15, 若執行 myint1.doublevalue(); 則取出值為 15.0D 換句話說, 拆箱代表執行了 xxxvalue 函式的動作 wapper class 觀念範例 11-9 :wapper class 的裝箱與拆箱 範例 11-9:ch11_09.java( 隨書光碟 myjava\ch11\ch11_09.java) /* 檔名 :ch11_09.java 功能 : 裝箱與拆箱 */ package myjava.ch11; import java.lang.*; public class ch11_09 public static void main(string args[]) Long mylongint = new Long("5"); long L1=myLongInt.longValue(); int I1=myLongInt.intValue(); //CRect obj= new CRect(L1,I1); CRect obj= new CRect(I1,I1); obj.showarea(); 執行結果 Area=25 // 裝箱 // 拆箱 // 拆箱 // 找不到建構子 78

40 wapper class class CRect protected int area; protected int len,width; public CRect(int i,int j)len=i; width=j; 並無一個建構子的參數串列為 public void showarea() (Long 型態,int 型態 ) area=len*width; System.out.println("Area=" + area); wapper class 範例說明 : (1) 第 10 行使用了 Long 類別, 並透過建構子, 將資料 5 進行裝箱 物件名稱為 mylongint (2) 第 11 行透過 longvalue 進行拆箱取出資料 5L 第 12 行透過 intvalue 進行拆箱取出資料 5 (3) 第 15 行建立 obj 物件時不會有錯誤, 因為傳入的是兩個整數引數 而第 14 行會有錯誤, 因為建構子中, 沒有符合資料型態的參數串列 80

41 wapper class 自動裝箱 (auto-boxing) 與自動拆箱 (auto-unboxing) 理論上, 我們在使用 wapper class 時, 必須進行裝箱與拆箱的動作來存放資料以及取出資料, 但在 JDK1.5 之後,Java 提供了自動裝箱與自動拆箱的功能, 這使得我們在使用時方便許多 自動裝箱代表的是當您將一個原始資料型態指定給一個包裹型態 (wapper type) 的物件變數時, 它會自動呼叫建構子, 以完成包裝資料的目的 wapper class 而當您直接取用一個包裹型態的物件變數時, 它則會呼叫對應的拆箱函式 請注意, 自動裝箱所使用的建構子不會是字串參數 而自動拆箱所使用的函式, 則是 相對應的原始資料型態名稱 +Value, 例如使用 Double 類別包裹資料, 則自動拆箱所使用的函式為 doublevalue, 它並不會自動呼叫 intvalue 觀念範例 :wapper class 的自動裝箱與自動拆箱 範例 11-10:ch11_10.java( 隨書光碟 myjava\ch11\ch11_10.java) 82

42 wapper class /* 檔名 :ch11_10.java 功能 : 自動裝箱與自動拆箱 */ package myjava.ch11; import java.lang.*; public class ch11_10 public static void main(string args[]) Double mydouble = 5.0; double D1= mydouble; //int I1=myDouble; int I1=myDouble.intValue(); System.out.println("D1=" + D1); System.out.println("I1=" + I1); 執行結果 D1=5.0 I1=5 // 自動裝箱 // 自動拆箱 // 自動拆箱失敗 // 拆箱 wapper class 範例說明 : (1) 第 10 行欲直接設定 5.0 給一個 Double 類別的物件, 此時會進行自動裝箱, 也就是自動呼叫 Double(double value) 建構子進行自動裝箱, 但您不能直接指定為字串 "5.0" (2) 第 11 行將物件變數 mydouble 直接指定給 double 資料型態的變數 D1 時, 會進行自動拆箱, 也就是呼叫 doublevalue() 函式 (3) 第 12 行若要執行自動拆箱, 則由於呼叫 doublevalue() 函式的回傳值資料型態為 double, 此時無法自動轉型, 故自動拆箱失敗, 此時會放棄自動拆箱 84

43 wapper class 小試身手 11 2 (4) 第 13 行我們自行使用 intvalue 進行拆箱, 由於資料型態相符, 所以不會有錯誤產生 (5) 由於自動拆箱仍舊容易發生資料衝突的現象, 因此自動拆箱是為了泛型而特別設計, 泛型的意思是可接受任何種類的資料型態, 我們將於後面章節中介紹 請將範例 的第 12 行註解取消, 第 13 行的 int 刪除, 然後重新編譯, 看看會獲得什麼結果? 延伸學習 : 自動裝箱與自動拆箱 如果讀者想要深入研究 Java 的自動裝箱與自動拆箱, 此處有一篇文章將對您有所幫助 String class Java 的原始資料型態並未提供字串型態, 所幸 Java 提供了 String 類別並且隸屬於 java.lang 類別庫以便自動匯入, 故我們可以在程式中大量使用字串 為了讓使用者方便使用字串,Java 允許使用者以較簡單的方式來宣告一個字串, 亦即如下語法範例 : String str="test"; 但若將 String 視為類別名稱, 則應該以下列語法來宣告字串為佳 : String str= new String("test"); 86

44 String class 由於字串是由一個一個字元所構成, 所以 Java 在 String 類別的建構子中, 也允許使用字元陣列當作引數來建立字串, 例如上述語法可以改寫如下 : char data[] = 't', 'e', 's', 't'; String str = new String(data); 不可變的字串事實上 String 類別產生的物件是一種不可變的 (immutable) 字串 也就是字串內容無法改變 或許您會覺得奇怪, 下面的兩個敘述不是可以將 str 的字串內容改變嗎? 為何說字串內容無法改變呢? String str = "test"; str = "Hello"; 事實上, 上列敘述一共會產生兩個字串物件, 一個字串長度為 4, 另一個字串長度為 String class 第一行時,str 指向第一個字串物件, 而第二行只不過是將 str 指向第二個字串物件, 並非將第一個字串物件的內容改變 並且若第一個字串物件在一段時間後仍未被其他物件變數參考的話, 它將會由 Java 的垃圾收回機制給回收, 所以程式設計師無須煩惱此一問題 而如果將上述的兩行敘述改變為下列兩行敘述, 情況仍然是相同的 String str = new String("test"); str = "Hello"; 88

45 String class 小試身手 8 4 因為 String 類別產生的 String 物件一定是不可變的, 所以即使您使用的是 new 來產生字串物件, 在第二行 str 仍舊會指向新的字串物件, 而非將原本的字串物件內容改變 ( 以上應該已經回答了小試身手 8-4 的疑惑 ) 請將範例 8 9 的第 11 行改為 str = "...";, 然後重新編譯, 看看是否可通過編譯? 如果無法通過編譯, 請暫時留下您的疑問, 我們會在第 11 章講解 String 類別時, 為您解答這個問題 final String str = new String ("final 修飾字的示範 "); str = new String("..."); 延伸學習 :wapper class 使用 wapper class 建立的物件內容與字串類似, 同樣具有不可變的性質 改變它的內容時, 實際上是產生一個新的物件實體, 並將物件參考指向新的物件實體 String class String Pool 雖然不論您是否使用 new 建立字串,String 字串都是不可變的字串 但是否使用 new 來建立字串還是有所差別的 對於 Java 而言, 任何的字串常數都是一個字串物件 為了更有效管理字串, 故 Java 採用 String Pool 方式集中管理字串常數 假設我們有下列兩行敘述, 則 str1 與 str2 兩個字串物件變數都將指向同一個字串 String str1 = "test"; String str2 = "test"; 這是因為字串常數會集中放在 String Pool 中, 當您直接指定一個字串值時, 它會先去 String Pool 中找尋是否有相同的字串可以使用, 如果有, 就會將其位址回傳, 因此 str1 與 str2 指向同一個 String Pool 內的字串物件 ( 內容為 test) 90

46 String class 假設我們有另外兩行敘述如下, 則 str3 與 str4 將會指向不同字串物件 String str3 = new String("abc"); String str4 = new String("abc"); 因為我們用 new 強迫產生了一個字串物件, 此時並不會先尋找是否有相同的字串可以使用 String class 事實上, 編譯器在處理上述的兩行敘述時, 一共會產生三個字串物件第一個為沒有名稱的字串物件, 內容為 "abc" 這是編譯器在看到 "abc" 字串常數後就產生的字串接著由於第一個 new 的緣故, 故強迫產生了第二個字串物件, 名稱為 str3, 並將內容設定為 abc 當第二次看到 "abc" 字串常數時, 由於 String Pool 內已經有一個字串物件為 "abc", 故不會再產生字串物件而第二次看到 new 時, 則強迫產生了第三個字串物件, 名稱為 str4, 並將內容設定為 abc 至於沒有名稱的字串物件, 則會由 Java 的回收機制自動回收 92

47 String class 現在我們來思考另一個問題, 以證明 String Pool 的存在, 假設有下列幾行敘述 : String str5 = "Hello"; String str6 = "World"; String str7 = "HelloWorld"; String str8; str8 = str5 + str6; 我們知道 str8 最後的結果為 "HelloWorld", 但是 str7 與 str8 是否指向同一個字串物件呢? String class 答案是否定的 因為採用了 + 運算子連結字串時, 預設並不會檢查 String Pool 內是否有相同的字串 但是有一個特殊的函式 intern() 可以強迫先檢查 String Pool 內是否有相同的字串, 若有則直接指定, 沒有相同的字串時才會產生新的字串 String str9 = (str5 + str6).intern(); 將上面的敘述加入後, 由於 intern 函式的緣故, str9 將會與 str7 指向同一個字串 94

48 String class 字串相等 字串相等 可分為兩種情況來討論 其一是兩個字串變數是否指向同一個字串物件實體 其二則是兩個字串的實質所有字元是否相等 當我們要比較兩個物件參考是否指向同一個物件實體時, 可以使用 == 來完成 而如果只是要比較字串的所有字元是否相等, 則可以使用 String 類別的 equals() 函式來比較 兩種方式的回傳值都是布林值, 我們透過下面這個範例來證明本小節之前所介紹的觀念 String class 觀念範例 :String 字串的觀念以及 equals() 函式 範例 11-11:ch11_11.java( 隨書光碟 myjava\ch11\ch11_11.java) /* 檔名 :ch11_11.java 功能 :String 字串的觀念 */ package myjava.ch11; import java.lang.*; public class ch11_11 // 主類別 public static void main(string args[]) String str1 = "test"; String str2 = "test"; if(str1==str2) // 答案為 true, 因為指向同一個字串 System.out.println("str1 與 str2 指向同一個字串物件 "); //

49 String class String str3 = new String("abc"); String str4 = new String("abc"); if(str3==str4) // 答案為 false, 因為指向不同字串物件 System.out.println("str3 與 str4 指向同一個字串物件 "); else System.out.println("str3 與 str4 指向不同字串物件 "); if(str3.equals(str4)) // 答案為 true System.out.println("str3 與 str4 內容相同 "); // String str5 = "Hello"; String str6 = "World"; String str7 = "HelloWorld"; String str8; str8 = str5 + str6; String str9 = (str5 + str6).intern(); if(str7 == str8) // 答案為 false, 因為指向不同字串物件 System.out.println("str7 與 str8 指向同一個字串物件 "); else System.out.println("str7 與 str8 指向不同字串物件 "); if(str7.equals(str8)) // 答案為 true System.out.println("str7 與 str8 內容相同 "); if(str7 == str9) // 答案為 true, 因為指向同一個字串物件 System.out.println("str7 與 str9 指向同一個字串物件 "); String class 執行結果 : 範例說明 : str1 與 str2 指向同一個字串物件 str3 與 str4 指向不同字串物件 str3 與 str4 內容相同 str7 與 str8 指向不同字串物件 str7 與 str8 內容相同 str7 與 str9 指向同一個字串物件 請讀者參照執行結果印證本節所介紹關於 String 字串的各種觀念 98

50 String class String 類別的建構子 建立 String 物件有很多種方式, 除了之前所介紹的之外, 在建立字串物件時還可以傳入其他種類的引數, 以下我們節錄其中幾個比較常用的建構子如下表 : 建構子宣告 說明 String() 無參數的建構子, 故為建立空字串 String(byte[] bytes) 以 byte 陣列內容建立字串 String(byte[] bytes, int offset, int length) 同上, 但從第 offset 位置開始取用, 長度為 length String(char[] value) 以字元陣列內容建立字串 String(char[] value, int offset, int count) 同上, 但從第 offset 位置開始取用, 長度為 count String(String original) 使用另一個字串物件來建立字串 您可以將之視為字串的複 String(StringBuffer buffer) 製 使用 StringBuffer 字串來建立字串 我們將於下一小節說明何 謂 StringBuffer 字串 String(StringBuilder builder) 使用 StringBuilder 字串來建立字串 我們將於最後一小節說明 何謂 StringBuilder 字串 String class String 類別與 char[] String 物件的內容實際上是使用 char[] 陣列存放各個字元, 您可以將該字元陣列當作是 String 物件的成員變數不過我們無法直接存取該成員, 在 Java 的類別原始碼中, 您可以查閱到下列成員, 說明了 String 物件是將字串中的各個字元存放在 value 字元陣列中, 不過由於被宣告為 private, 因此無法直接存取 private final char value[]; 如果一定要取得該字元陣列的內容, 也可以透過 tochararray() 函式來完成 100

51 String class String 類別的常用函式 String 類別提供了許多的函式可供使用, 以下節錄幾個常用且重要的函式如下表請切記 String 字串是不可變動的字串, 故大多數提供的函式都是測試或查詢功能, 即使有一些函式具有轉換功能, 也不是轉換字串物件的內容, 而是回傳一個新的字串物件, 該物件存放著轉換後的結果 同時, 若函式多載, 則只列出部分常用參數的情況, 其餘請自行查閱 Java 說明文件 : String class String 類別的常用函式 說明 與特定位置字元相關 char charat(int index) 回傳字串第 index 個字元, 並且由 0 開始計數 int indexof(int ch) 尋找字元 ch 在字串之字元陣列的索引位置, 若找不到, 則回傳 - int indexof(int ch, int fromindex) 1 同上, 但由第 fromindex 個索引開始往後尋找 int indexof(string str) 尋找字串 str 在字串之字元陣列的索引位置, 若找不到, 則回傳 - int indexof(string str, int fromindex) 1 同上, 但由第 fromindex 個索引開始往後尋找 int compareto(string anotherstring) int comparetoignorecase(string str) boolean contentequals(stringbuffer sb) boolean equals(object anobject) 與字串比較相關 當物件本身的所有字元與 anotherstring 的所有字元都相同時, 則回傳 0 否則, 由第一個字元開始比較兩者, 直到比到不同的字元時, 若物件本身的字元編碼較大, 則回傳正整數 ; 否則回傳負整數 同上, 但比較字元時, 將大小寫視為相同字元 與 sb 字串 ( 另一種字串 ) 比較內容, 相同時回傳 true, 不同時回傳 false 與物件比較內容, 只有該物件為字串物件, 且內容相同時, 才會回傳 true, 否則回傳 false 102

52 String class String 類別的常用函式 boolean equalsignorecase(string anotherstring) boolean isempty() int length() boolean startswith(string prefix) boolean startswith(string prefix, int toffset) boolean endswith(string suffix) String concat(string str) String intern() String replace(char oldchar, char newchar) String substring(int beginindex) String substring(int beginindex, int endindex) 與字串比較相關 說明 與 anotherstring 字串比較內容, 且忽略大小寫的不同 用來檢查是否為空字串 若字串長度為 0, 則回傳 true, 否則回傳 false 回傳字串的長度, 也就是字串包含了幾個字元 測試字串開頭是否與 prefix 字串相同 同上, 但由 toffset 索引開始作為開頭 測試字串結尾是否與 suffix 字串相同 回傳特定的新字串 回傳以原字串連結 str 字串後的字串 在 String Pool 中, 尋找是否有可用的字串物件, 若有則回傳以便共用, 若無則建立新的字串物件 回傳一個字串, 該字串內容是將原字串內容中的 oldchar 字元替換為 newchar 字元 從其內字元陣列的第 beginindex 個索引開始取得字串內容並回傳 從其內字元陣列的第 beginindex 個索引開始取得字串內容直到第 endindex-1 個索引並回傳 String class String 類別的常用函式 回傳特定的新字串 String tolowercase() 回傳一個字串, 其內容為原字串內容, 但全以小寫字母表示 String tostring() 回傳物件本身的實體 ( 參考位址 ) String touppercase() 回傳一個字串, 其內容為原字串內容, 但全以大寫字母表示 String trim() 回傳一個字串, 該字串內容是原字串去除尾端的空白字元 回傳特定的陣列 byte[] getbytes() 將字串的所有字元, 以 byte 陣列存放, 並回傳該 byte 陣列 char[] tochararray() 將字串物件的字元陣列複製一份並回傳 類別方法 ( 不須產生物件即可使用 ) static String valueof( 參數列 ) 將其他資料型態以字串型式表示 static String copyvalueof(char[] data) 複製 data 字元陣列的內容, 並以此產生一個字串 說明 static String copyvalueof(char[] data, int offset, int count) 同上, 但指定由第 offset 個字元開始複製 count 個字元 104

53 String class 觀念範例 :String 字串的函式練習 範例 11-12:ch11_12.java( 隨書光碟 myjava\ch11\ch11_12.java) /* 檔名 :ch11_12.java 功能 :String 字串的函式練習 */ package myjava.ch11; import java.lang.*; public class ch11_12 // 主類別 public static void main(string args[]) String str = " 中文字串測試 "; String str1 = "This is a book"; String str2; System.out.println(" 字串 [" + str + "] 共有 " + str.length() + " 個字元 "); System.out.println(" 字串 [" + str1 + "] 共有 " + str1.length() + " 個字元 "); System.out.println(" 字串的字首為 is==>" + str1.startswith("is")); String class System.out.println(" 轉換為大寫字元 =>" + str1.touppercase()); System.out.println(" 在字元陣列中第 [5] 個字元為 =>" + str1.charat(5)); str2=str1.substring(5); System.out.println(" 第 [5] 個字元之後的子字串為 " + str2); System.out.println(" 子字串的字首為 is==>" + str2.startswith("is")); 執行結果 : 字串 [ 中文字串測試 ] 共有 6 個字元字串 [This is a book] 共有 14 個字元字串的字首為 is==>false 轉換為大寫字元 =>THIS IS A BOOK 在字元陣列中第 [5] 個字元為 =>i 第 [5] 個字元之後的子字串為 is a book 子字串的字首為 is==>true 106

54 String class 範例說明 : 由 str 字串可知, 中文字元也是佔用一個字元, 因為 Java 採用的是 Unicode, 故不論中英文字元都當作一個字元 請讀者自行對照函式與執行結果的輸出以了解函式功能 StringBuffer 類別 String 字串不可改變其內的字元, 但在實際應用時, 卻常常需要改變字串的字元或者延伸字串的長度 此時, 我們可以改用 StringBuffer 字串 StringBuffer 字串宣告時必須透過 StringBuffer 類別的建構子來完成, 不能直接設定為字串常數 若您在產生 StringBuffer 物件時, 給定了初始字串, 則 StringBuffer 字串預留的空間為 16+ 字串長度 個字元若您在產生 StringBuffer 物件時, 未給定初始字串, 則預留的空間為 16 個字元 除此之外, 我們也可以在產生物件時, 直接指定預留空間的容量 其建構子的語法節錄如下 : 108

55 StringBuffer 類別 StringBuffer() // 容量預留為 16 個字元 StringBuffer(CharSequence seq) // 用特定的 CharSequence 類別建構字串內容 StringBuffer(int capacity) // 直接指定初始容量 StringBuffer(String str) // 使用 String 類別建構字串內容, 容量為 16+str.length() 語法說明 : 上述語法第四項的範例如 StringBuffer("This is a book"), 由此可知, 字串常數在 Java 中使用的是 String 字串而非 StringBuffer 字串, 這是很合理的, 因為字串常數並不會改變其值 當 Java 編譯器遇到下列敘述時, 實際上會產生兩個字串 StringBuffer strbuf=new StringBuffer("This is a book"); 一個是 StringBuffer 字串, 另一個是沒有名稱的 String 字串, 其內容為 This is a book, 接著將此字串當作是引數傳遞給 StringBuffer 字串的建構子 StringBuffer 類別 StringBuffer 類別的常用函式 StringBuffer 類別提供了許多的函式可供使用, 並且除了測試與觀察功能的函式之外, 也提供了可以修改內容的函式, 因為 StringBuffer 字串可以變動其內容以下節錄幾個常用且重要的函式如下表, 其餘請自行查閱 Java 說明文件 : 110

56 StringBuffer 類別 StringBuffer 類別的常用函式 char charat(int index) int indexof(string str) int indexof(string str, int fromindex) int capacity() int length() String tostring() String substring(int start) String substring(int start, int end) 與特定位置字元相關 說明 回傳字串第 index 個字元, 並且由 0 開始計數 尋找字串 str 在字串之字元陣列的索引位置, 若找不到, 則回傳 -1 同上, 但由第 fromindex 個索引開始往後尋找 與長度及容量相關 回傳字串的預留容量 回傳字串的長度, 也就是字串包含了幾個字元 回傳特定的 String 字串 回傳 String 字串, 字串內容與該字串物件的內容相同 這個函式可以用來轉換字串格式 回傳第 start 個字元開始的子字串, 並且回傳的字串格式為 String 字串 回傳第 start 個字元 ~ 第 end-1 個字元的子字串, 並且回傳的字串格式為 String 字串 StringBuffer 類別 StringBuffer 類別的常用函式 修改字串內容 StringBuffer delete(int start, int end) 刪除第 start 個 ~ 第 end-1 個字元 ( 後面往前移動 ) StringBuffer deletecharat(int index) 刪除第 index 個字元 ( 後面往前移動 ) StringBuffer insert(int offset, char c) 在第 offset 個字元處, 插入字元 c ( 後面的原始子字串往後移 動 ) StringBuffer insert(int offset, String str) 在第 offset 個字元處, 插入 str 字串內容 ( 後面的原始子字串 往後移動 ) StringBuffer append(char c) 在字串尾端加上字元 c StringBuffer append(string str) 在字串尾端加上 str 字串內容 StringBuffer replace(int start, int end, String str) setcharat(int index, char ch) 將第 index 個字元更改為 ch StringBuffer reverse() 字串內容反轉 說明 第 start 個字元 ~ 第 end-1 個字元, 以 str 字串內容取代 ( 字串長度可能會變動 ) 112

57 StringBuffer 類別 StringBuffer 類別的常用函式說明設定相關 void ensurecapacity(int 重新設定字串的容量 只會增大不會減少原始容量 minimumcapacity) void setlength(int newlength) 重新設定字串長度, 若新長度較小, 則多餘的字元會被捨棄, 若新長度較大, 則新增的字元將被初始為 '\u0000', 這是歸位換行字元 無 類別方法 ( 不須產生物件即可使用 ) 說明 修改字串內容的函式若回傳一個 StringBuffer 字串的參考位址, 則該參考位址事實上也就是原該字串的參考位址 StringBuffer 類別 觀念範例 :StringBuffer 字串的函式練習 範例 11-13:ch11_13.java( 隨書光碟 myjava\ch11\ch11_13.java) /* 檔名 :ch11_13.java 功能 :StringBuffer 字串的函式練習 */ package myjava.ch11; import java.lang.*; public class ch11_13 // 主類別 public static void main(string args[]) StringBuffer strbuf = new StringBuffer(" 中文字串測試 "); StringBuffer strbuf1 = new StringBuffer("This is a book!"); System.out.print(" 字串 [" + strbuf + "] 共有 "); System.out.println(strBuf.length() + " 個字元 "); StringBuffer strbuf2 = strbuf.reverse(); System.out.println("strBuf 字串容量為 " + strbuf.capacity() + " 個字元 "); System.out.println("strBuf 反轉後為 [" + strbuf +"]"); strbuf.setcharat(3,'t'); System.out.println("strBuf2 為 [" + strbuf2 +"]"); strbuf 與 strbuf2 指向同一物件 strbuf2 也會受到影響 114

58 StringBuffer 類別 System.out.print("strBuf1 原始字串內容為 " + strbuf1); System.out.println(" 長度為 " + strbuf1.length()); strbuf1.replace(10,14,"pen"); // 修正第 10~13 個字元為 pen System.out.print("strBuf1 更改後其內容為 " + strbuf1); System.out.println(" 長度為 " + strbuf1.length()); 執行結果 : 字串 [ 中文字串測試 ] 共有 6 個字元 strbuf 字串容量為 22 個字元 strbuf 反轉後為 [ 試測串字文中 ] strbuf2 為 [ 試測串 t 文中 ] strbuf1 原始字串內容為 This is a book! 長度為 15 strbuf1 更改後其內容為 This is a pen! 長度為 StringBuffer 類別 範例說明 : (1) 由執行結果可知 StringBuffer 字串的中文字也是佔用一個字元 (2) 當使用 String 字串作為初始建構子的引數時, 預留的容量為 16+ 字串長度 (3) 第 14 行將字串反轉, 而 strbuf2 接收此反轉後的字串, 事實上, 由於反轉也是在更動其內的字串, 所以 strbuf 與 strbuf2 參考到同一個物件 所以第 17 行設定 strbuf 的字元時,strBuf2 的字串內容也被改變 (4)replace 會改變字串的長度 116

59 StringBuffer 類別 為何需要 String 與 StringBuffer 兩種字串類別 String 類別的字串不可改變其值, 而 StringBuffer 類別的字串可以改變其值,Java 為何不直接提供一種可改變其值的字串, 而將字串分為這兩種呢? 原因在於 Java 支援了多執行緒, 由於多執行緒有同步的問題, 因此對於會被寫入的變數, 可能會發生非預期的狀況 在台灣高鐵初通車時, 曾發生過一位多賣的重複賣票問題, 就極有可能是因為同步出了問題 對於高鐵的賣票系統而言, 它的賣票終端機可能來自各個車站的眾多來源, 換句話說, 將有許多相同的程式同時執行並預備訂下某一個位置, 若同步問題未處理得宜, 則可能發生重複賣票的問題 ( 我們將會在多執行緒一章中詳細討論 ) StringBuffer 類別 同理, 由於 Java 支援多執行緒, 相當於多個相同的程式同時執行並且這些程式可能會寫入同一個變數, 如此一來, 變數的最終值將難以預估 因此, 若字串可更改, 則必須在多執行緒環境中, 多設計一些機制, 以維護字串的變動, 如此將使得執行效率變得比較慢, 但若字串內容是唯讀的, 則即使在多執行緒環境中, 也不須進行特別的維護, 因為所有執行緒讀到的都將是相同的字串內容 換句話說,Java 提供了多執行緒功能, 而為了提高效率, 因此將唯讀的字串獨立出來成為一個類別, 由於早期的 JVM 執行效率較差, 故 Java 類別庫儘可能提供高效率的類別是合理且重要的 這也就是為何會出現 String 與 StringBuffer 兩種字串類別的主要原因 118

60 StringBuilder 類別 StringBuffer 與 StringBuilder 類別的功能完全相同, 且都是可改變內容的字串, 唯一不同的是 StringBuilder 採用的是非同步的策略, 而 StringBuffer 採用的是同步的策略 我們將於多執行緒一章中解釋何謂同步與非同步 總之, 若應用程式只需要執行單一個執行緒時, 採用 StringBuilder 類別會比較有效率, 因為它不需要為了同步提供一些維護機制 StringBuilder 類別 下列是使用字串時, 採用 String StringBuffer 或 StringBuilder 類別的幾點建議 : 若字串內容不會變動 請使用 String 物件, 因為它是不會變動且效率佳的字串 若字串內容會變動, 但執行環境僅限於單一執行緒 請使用 StringBuilder 物件, 因為它的執行效率比 StringBuffer 佳 若字串內容會變動, 但執行環境可能出現多執行緒 請使用 StringBuffer 物件, 因為它能夠保證在多執行緒的環境下, 維護字串的同步 120

61 StringBuilder 類別 想太多? 事實上, 大多數的程式設計都採用 String 物件來存放字串即可, 因為有 String Pool 與自動回收的機制, 因此不必考慮太多, 只要方便就好 不過由於 Java 有認證機制, 所以還是要了解這三種字串的區別 Math 類別 電腦程式在工程應用上頗為廣泛, 而工程應用則大量使用眾多的數學公式及常數, 例如自然指數 e, 圓周率 π, 三角函數等等 當然我們可以自行定義相關的常數, 例如將圓周率使用 final 變數 pi 定義為 3.14, 可是如果要取得精確度極高的數值時, 該怎麼辦呢? 同理, 如果我們需要使用三角函數 sin(x), 要如何求得呢? 如果您學過泰勒級數, 可能會說, 使用迴圈實作泰勒級數可以求得 sin(x), 問題是這似乎太麻煩且沒有效率了 事實上, 除非您有特殊的數學需求, 否則並不用這麼麻煩, 因為程式語言通常都會提供與數學相關的函式庫,Java 也不例外 122

62 Math 類別 而 Java 把這些與數學相關的常數與函式都放在 java.lang 的 Math 類別中 請注意, 本節所介紹的 Math 類別是放置於 java.lang 類別庫中, 而非 java.math 類別庫 java.math 類別庫提供的類別通常是用來處理大數 ( 超過 Java 原始資料型態之極大值 ) 運算之用, 由於已經超過本書範圍, 故不多加介紹 在 Math 類別中, 記錄了兩個靜態的 final 變數, 分別用來代表自然指數 e 與圓周率 π, 如下表 由於是類別變數 ( 靜態變數 ), 所以不須產生物件就可以使用 static final 變數宣告 public static final double E public static final double PI 意義 代表自然指數 e 的常數值, 其值記錄為 代表圓周率 π 的常數值, 其值記錄為 Math 類別 在 Math 類別中, 也定義了許多的數學函數, 節錄部份重要函式如下表 同樣地, 它們也全都是類別方法, 所以不須產生物件就可以使用 static 數學函式 意義 與指數對數相關 static double log(double a) 回傳 a 的自然對數 ( 以 e 為底 ) static double log10(double a) 回傳 a 的對數 ( 以 10 為底 ) static double exp(double a) 自然指數功能, 回傳 e a static double pow(double a, double b) 次方功能, 回傳 a b static double sqrt(double a) 開根號功能, 回傳 124

63 Math 類別 static 數學函式 意義 與三角函數相關 static double sin(double a) 正弦函數功能, 回傳 sin(a), 其中 a 為弳度 static double cos(double a) 餘弦函數功能, 回傳 cos(a), 其中 a 為弳度 static double tan(double a) 正切函數功能, 回傳 tan(a), 其中 a 為弳度 static double asin(double a) 反正弦函數功能, 回傳 sin -1 (a) static double acos(double a) 反餘弦函數功能, 回傳 cos -1 (a) static double atan(double a) 反正切函數功能, 回傳 tan -1 (a) static double sinh(double x) 雙曲正弦函數功能, 回傳 sinh(x) static double cosh(double x) 雙曲餘弦函數功能, 回傳 cosh(x) static double tanh(double x) 雙曲正切函數功能, 回傳 tanh(x) 與整數相關 static double ceil(double a) 回傳 a 的最小整數 ( 相當於上高斯符號 ) static double floor(double a) 回傳 a 的最大整數 ( 相當於下高斯符號 ) static long round(double a) static int round(float a) 多載函式, 回傳最接近 a 的整數 Math 類別 static 數學函式 static double random() static double max(double a, double b) static float max(float a, float b) static int max(int a, int b) static long max(long a, long b) static double min(double a, double b) static float min(float a, float b) static int min(int a, int b) static long min(long a, long b) static double abs(double a) static float abs(float a) static int abs(int a) static long abs(long a) 意義其他亂數功能 回傳一個隨機值, 介於 0.0~1.0 之間多載函式, 回傳 a 與 b 中較大者 多載函式, 回傳 a 與 b 中較小者 多載函式, 回傳 a 的絕對值 126

64 Math 類別 實用範例 : 使用數學類別, 計算 sin(π/2)=sin(90 ) 範例 11-14:ch11_14.java( 隨書光碟 myjava\ch11\ch11_14.java) /* 檔名 :ch11_14.java 功能 :StringBuffer 字串的函式練習 */ package myjava.ch11; import java.lang.*; public class ch11_14 // 主類別 public static void main(string args[]) double a=0.5*(math.pi); double x=0.5*180; // 弳度 PI=180 度 System.out.println("sin(" + x + " 度 )=" + Math.sin(a)); Math 類別 執行結果 : sin(90.0 度 )=1.0 範例說明 : 數學類別庫的三角函數功能, 其引數須為弳度量, 1π=

65 11.7 變數及方法的封裝等級 在 節中, 我們介紹過封裝等級直接使用於類別時只有兩種選擇, 一個為不寫封裝等級, 另一個則是將類別宣告為 public 等級 若類別未宣告為 public 等級, 則對於其他不同類別庫的類別而言, 它是不可被取用的 ( 當然也不可被繼承 ) 並且一個檔案只能有一個 public 等級的類別 變數及方法的封裝等級 雖然在表 11-1 中, 我們也介紹過封裝等級使用於修飾類別內的成員, 但並未詳細加以討論, 在本節中, 我們將重新檢討封裝等級的修飾對象為類別的成員時, 會造成什麼影響 變數及方法的封裝等級牽涉到在程式的 某處 是否可以取用某個變數或執行某個方法 這也就是變數及方法的可見度 (Visibility) 問題 由於 Java 多了一種 類別庫可見度, 故我們直到本章才討論這個問題, 而非在繼承一章討論這個問題 事實上, 也因為 Java 多了一種類別庫可見度, 因此 protected 的規定與其他物件導向語言可能有些不同 130

66 11.7 變數及方法的封裝等級 在 Java 中, 四種封裝等級的可見度可以分為四種層級來討論, 我們將之整理如表 11-3: 封裝修飾字 類別內 類別庫內 子孫類別內 其他 public 等級 protected 等級 Χ 未寫封裝等級 Χ Χ private 等級 Χ Χ Χ 表 11-3 類別內之成員的封裝等級之存取權限 (Access Level) 變數及方法的封裝等級 橫列說明 :( 以下討論以變數的存取來討論, method 的執行亦同理 ) (1)public 等級 : 任何地方的程式都可以取用 (2)protected 等級 : 在其他程式語言中, 通常 protected 等級的變數只有類別本身與子孫類別可以取用它 (Java 也是如此 ), 但 Java 由於多了一個類別庫可見度, 故只要是同一個類別庫內的敘述, 也都可以取用它 ( 不必有繼承關係 ) 例如您將範例 8-1 的第 25 行註解取消, 仍可以正確編譯 Coding 注意事項 protected 等級的成員可以讓同一 package 的任何類別來存取, 而若要在不同的 package 中存取, 則必須透過繼承才能達到 132

67 11.7 變數及方法的封裝等級 (3) 未寫封裝等級 : 若變數在類別內, 未被宣告任何的封裝等級, 則為預設的封裝等級, 您也可以將之視為類別庫封裝等級 ( 正確名稱為 packageprivate 等級 ) 顧名思義, 只要是同一個類別庫內的敘述, 都可以取用它 (4)private 等級 : 若一個變數被宣告為 private 等級, 則除了該類別可以存取之外, 其餘皆不可存取它 唯一比較特殊的是 ( ), 子類別內的敘述雖不能直接存取該變數, 但可以透過父類別原有的函式間接存取該變數 變數及方法的封裝等級 直行說明 :( 以下討論以變數的存取來討論,method 的執行亦同理 ) (1) 類別內 : 在同一類別內, 不論變數被宣告為哪一種等級, 都可以取用它 (2) 類別庫內 : 在同一類別庫內的不同類別, 除了變數被宣告為 private 等級, 否則也可以取用它 (3) 子孫類別內 : 除了可以取用 public 等級的變數外, 若變數被宣告 protected 等級, 則也可以因為繼承關係而取用它 而若子孫類別與父類別位於同一 package, 則按照 (2) 之規範為準 134

68 11.7 變數及方法的封裝等級 (4) 其他 : 其他代表著是存取敘述與被存取的變數, 既不位於同一類別, 也不位於同一類別庫, 同時也沒有繼承關係 此時, 只能存取被宣告為 public 的變數 雖然上述的 其他 可以取用被宣告為 public 的變數, 但若該變數所屬類別與存取敘述位於不同類別庫, 且該變數所屬類別未宣告為 public 類別, 則仍舊無法存取該變數 因為未宣告為 public 的類別, 其他類別庫的程式就不能取用它, 更不用說是它的成員了 ( 節已說明此規定 ) 變數及方法的封裝等級 在第 8 章中, 我們曾介紹, 若一個類別的成員只希望給類別本身及其子孫類別使用 ( 不希望給外部程式使用 ), 則該成員應該宣告為 protected 等級, 但這是有前提的 簡單來說, 只有當外部程式與該類別位於不同的 package 時, 外部程式才無法使用 protected 等級的成員 如果外部程式與類別位於相同的 package 時, 外部程式仍舊可以使用 protected 等級的成員 因此, 如果您將範例 8-1 的第 25 行註解取消, 仍可以正確編譯 136

69 11.7 變數及方法的封裝等級 如果希望某一個類別成員只能讓類別本身與子孫類別存取, 但不希望被沒有繼承關係的類別存取, 在其他程式語言中, 使用 protected 等級就能夠解決, 但在 Java 中, 這樣子還是不夠的在表 11-3 的第 2 列 (protected 等級那一列 ) 中, 可以發現我們想要的效果是將表格第 2 列的第二個 喪失功能, 因此, 我們需要將類別分割隸屬於不同的 package, 才能達到目的 現在我們已經學會如何將類別分別隸屬於不同的 package, 因此, 現在可以示範如何讓一個成員只能被類別本身與子孫類別存取, 請見下列範例 變數及方法的封裝等級 觀念範例 : 改寫範例 8-1, 使得 vary 只能被類別本身與子孫類別存取 範例 11-15:CA.java( 隨書光碟 myjava\ch11\pack6a\ca.java) // 檔名 : 位於 pack6a\ca.java package pack6a; import java.io.console; ///CA 隸屬於 pack6a package // 由於需要使用 Console 類別, 故引入 Console 類別 public class CA Console console = System.console(); public int varx; protected int vary; private int varz; public void inputx() System.out.print("varX:"); varx=integer.parseint(console.readline()); 138

70 11.7 變數及方法的封裝等級 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); 變數及方法的封裝等級 ch11_15.java( 隨書光碟 myjava\ch11\pack6b\ch11_15.java ) /* 檔名 :ch11_15.java 功能 : 不同 package 使得 protected 產生作用 */ package pack6b; import pack6a.ca; //ch11_15 與 CB 皆隸屬於 pack6b package // 由於要使用 CA, 故需要引入 public class ch11_15 // 主類別 public static void main(string args[]) 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(); objb.inputy(); objb.inputz(); 140

71 11.7 變數及方法的封裝等級 外部程式無法存取 protected 等級資料 objb.varx++; //objb.vary++; objb.addone(); System.out.print(" 類別 B 的 objb 物件 :"); objb.show(); class CB extends CA // 類別 CB 繼承自類別 CA public int varw; // 新增的成員變數 public void addone() // 新增的成員函式 varx++; vary++; //varz++; // 無法存取父類別 private 等級資料 變數及方法的封裝等級 執行結果 : 範例說明 : C:\myJava\ch11>javac pack6a\ca.java C:\myJava\ch11>javac pack6b\ch11_15.java C:\myJava\ch11>java pack6b.ch11_15 輸入類別 CA 的 obja 物件資料 varx:10 vary:10 varz:10 類別 CA 的 obja 物件 :varx=10 vary=10 varz= 輸入類別 CB 的 objb 物件資料 varx:20 vary:20 varz:20 類別 B 的 objb 物件 :varx=22 vary=21 varz=20 (1) 這個程式將範例 8-1 的三個類別切割為兩個檔案, 分別隸屬兩個 package 和範例 8-1 相比, 除了主類別名稱改變之外, 本範例還將 CA 改為 public 類別, 因為它必須被其他 package 的類別使用 而執行結果則與範例 8-1 相同 142

72 11.7 變數及方法的封裝等級 (2) 範例 8-1 的第 25 行取消註解仍可編譯成功, 這代表著雖然 vary 被宣告為 protected 等級, 但外部程式 ( ch8_01 主類別 ) 仍可以存取它 而本範例若將 ch11_15.java 的第 25 行取消註解, 則編譯會失敗, 錯誤訊息如下, 這是因為它們已經分屬不同的 package, 此時 protected 發生作用, 只有類別本身與子孫類別可以取用 ( 如第 38 行 ) C:\myJava\ch11>javac pack6b\ch11_15.java pack6b\ch11_15.java:25: error: vary has protected access in CA objb.vary++; // 外部程式無法存取 protected 等級資料 ^ 1 error 變數及方法的封裝等級 (3) 本範例的 pack6a 類別庫只能有一個類別 CA, 如果還有其他類別 ( 如 CC 類別 ) 也隸屬 pack6a 類別庫的話, 那麼 CC 類別仍舊可以存取 vary( 不必有繼承關係 ), 故在規劃類別與類別庫時, 也應該考慮到此因素 144

73 11.8 本章回顧 package 可以想像為類別庫, 它是收納與管理類別的地方 為了避免類別或介面的名稱衝突,Java 採用 package 來管理類別, 而 package 以目錄為單位, 由於目錄在檔案系統中的路徑必定唯一, 故只要相同 package 中沒有同名的類別就不會有名稱衝突的問題 (1)Java 規定 package 名稱必須與目錄名稱一致, 若要將某個類別宣告為某個 package 則必須在該程式檔中加入 package 敘述 (2) 我們可以設定 CLASSPATH 環境變數, 以方便執行類別檔 本章回顧 (3) 欲使用其他 package 的類別, 需要遵守下列兩項規則 : 只能取用其他類別庫被宣告為 public 的類別 使用該類別時應該要將其類別庫名稱也明確指定, 格式為 類別庫名稱. 類別名稱 或使用 import 將類別匯入, 語法如 import 類別庫名稱. 類別名稱 ; (4) 宣告類別所使用的封裝修飾字對於類別的使用權限會產生變化, 只有被宣告為 public 的類別才可被其他類別庫使用 (5) 每一個 Java 原始檔中, 只能有一個 public 類別 若僅願意開放給他人使用但不希望他人繼承, 則應該宣告為 public final 類別 146

74 11.8 本章回顧 (6) 我們也可以將 package 以階層關係分為子類別庫 (sub-package), 通常會分為子類別庫都是因為類別庫間有階層關係, 例如 java.awt 為視窗程式設計類別, 而其下有子類別庫 java.awt.color, java.awt.font 等等 而宣告類別屬於某個子類別庫時, 也必須將其上的類別庫名稱記載於 package 敘述內, 並且使用. 進行階層的分隔 (7)import 類別庫名稱.*; 可以匯入該類別庫的所有類別, 但不包含子類別庫的類別 (8) 即使未撰寫 import java.lang.*;, 編譯器仍會自動匯入 java.lang 的所有類別 (9) 我們可以透過 wapper class( 包裹類別 ) 將原始資料型態的變數進行裝箱與拆箱的動作 並且在 JDK1.5 之後,Java 提供了自動裝箱與自動拆箱的功能 本章回顧 (10)String 類別提供的字串是不可變動的字串 所有在程式中出現的字串常數, 編譯器都會自動產生一個無名的 String 物件來存放, 並且這些字串常數會存放在 String Pool 中以便有效管理 (11)StringBuffer 類別提供的字串是可變動的字串, 由於必須考量到多執行緒環境, 因此效率較差 若您非常肯定執行環境非多執行緒, 也可以改用 StringBuilder 類別來存放可變動的字串 (12)java.lang.Math 類別提供大量與數學有關的方法, 也定義了 PI 與 E 兩個常數 (final 變數 ) (13) 四種封裝等級的可見度可以分為四種層級來討論, 我們將之整理在表 11-3, 其中 protected 等級的成員可以讓同一 package 的任何類別來存取, 而若要在不同的 package 中存取該成員, 則必須透過繼承才能達到目的 148

75 本章結束 Q&A 討論時間 149