# 01 泛型和集合物件

泛型

Java 5 之後加入泛型，使型別使用多了另一種彈性。

集合物件（用來裝填物件）＋泛型，可以限制裝填物件的型別。

使用泛型的效益

1. 提供更彈性的「型別安全 type safety」檢查機制，原本在執行時才能發現的型別錯誤，現在在編譯時期就可以預發現
2. 在集合物件 Collections 裡大量使用，限制內涵物件之型別
3. 減少轉型 casting 需要，使程式碼更簡潔

使用泛型設計類別

• 可以將程式碼裡的符號 T換成 String( 即 UseString())，或換成 Shirt (即 UseShirt())
• 常見的符號及表示方式如下：
  1. T -「型別（type）」
  2. E -「成員（element）」
  3. K -「鍵 - 值對裡的鍵（key）」
  4. V -「鍵 - 值對裡的值（value）」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class UseAny<T> {
    private T t;
    public void add(T t) {
        this.t = t;
    }
    public T get() {
        return this.t;
    }
}

class UseString {
    private String message;
    public void add(String message) {
        this.message = message;
    }
    public String get() {
        return this.message;
    }
}

class UseShirt {
    private Shirt shirt;
    public void add(Shirt shirt) {
        this.shirt = shirt;
    }
    public Shirt get() {
        return this.shirt;
    }
}

• Java 7 開始，取消「參考型別」和「建構子」都必須在<>符號內加上置換型別的規定，因為等號右側可以由前者推斷（inference）而知其型別

  1 2 3 4 5

  UseAny<String> shirt2 = new UseAny<Shirt>(); UseAny<String> msg2 = new UseAny<String>(); // see below for simplified code UseAny<String> shirt2 = new UseAny<>(); UseAny<String> msg2 = new UseAny<>();

集合物件

Collection 定義與種類

集合物件 Collection 相較陣列具備更多管理功能：

1. 以 interface Collection 為代表
2. 集合內物件 elements，簡寫為 E
3. 集合內物件必須為參考型別或基本型別的包裹類別 wrapper class
4. 有多種常見資料結構，例如 stack、queue、dynamic array 等
5. 大量使用泛型 generic
6. 都屬於 java.util.* package
7. interface Collection 繼承了 interface Iterable，因此所有集合物件都具備使用 Iterator (疊代器) 的能力

List

集合物件底下最常使用的介面，具備 index 能依照放入先後區分順序 order

1. 新增 element，使用 index 指定插入位置
2. 新增 element，直接加到尾端
3. 取得 element index
4. 使用 index 移除或覆寫成員
5. 取得 List 長度

ArrayList : List 最常使用的一種實作類別

• 特色：
  1. 行為和陣列 array 相近，但長度可以自動成長，又稱為「動態陣列」(dynamic array)
  2. 使用 index 新增 / 存取 / 修改 element
  3. 可以用 index 區分，所以允許重複成員
• 未搭配泛型設計的 List
  1. 使用 Iterator 取出的物件必須轉型
  2. 錯放成員時，在執行時期才能知道 (e.g. add Integer, add Integer, and then add String)

自動裝箱 Boxing和開箱 Unboxing

1. Primitive → Wrapper Class : 把基本型別裝箱 Boxing

2. Wrapper Class → Primitive : 將基本型別由包裹類別的箱子裡取出，開箱 Unboxing

3. 在迴圈內使用 boxing / unboxing 會讓效能耗損增幅

   1 2 3 4

   Integer partNumObj = elements.next(); int partNum = partNumObj.intValue(); // see below for concised code int partNum = elements.next();

Set

1. 其成員 element 必須為獨一無二（unique），不能重複

2. 沒有 index

3. 若放入重複 element，不會出錯，但無效

4. 常使用 HashSet 實作類別。TreeSet 類別會依物件特性自動排序

5. element 是否唯一，或是排序先後，取決於方法 equals() 和 hashCode() 的覆寫結果

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

   public class TestSet { public static void testHashSet() { Set<String> set = new HashSet<>(); set.add("uno"); set.add("deux"); set.add("trois"); set.add("trois"); for (String s : set) { System.out.println("item: " + s); // only prints "trois" once } } public static testTreeSet() { Set<String> set = new TreeSet<>(); set.add("uno"); set.add("deux"); set.add("trois"); set.add("trois"); set.add("turban"); for (String s : set) { System.out.println("item: " + s); // only prints "trois" once // print by String alphabetical order: d, tr-, tu-, u } } }

Deque (Queue)

Interface Deque 繼承了介面 Queue，特色如下：

1. Double-Ended Queue : 具備兩端點的 Queue

2. 可同時使用於 Stack 和 Queue 兩種資料結構，只要呼叫不同方法

   • 使用add()、remove()時：Deque 物件表現出 Queue 資料結構的行為 (FIFO)
   • 使用push()、pop()時：Deque 物件表現出 Stack 資料結構的行為 (FILO)

3. Deque<String> deque = new ArrayDeque<>();

Map

• Map 是 key - value 成對集合，但不屬於 Collection 集合物件家族

  1. key 物件 : 用來尋找 value 物件，每個 key 物件須為獨特而不重複的
  2. value 物件 : 和 key 物件有關連性（associative）

• 在其它語言中，Map 又稱「關聯性陣列 associative arrays」，key 可構成一陣列，value 可構成另一個陣列，兩陣列有著關聯性

• Map 泛型 <K, V>

• Map 基本用法

  • map.values() 取得 Collection<T of V>
  • map.keySet() 取得 Set<T of K> (因為 keys 不能重複，回傳 Set 而非 Collection)

• Map 並未繼承於 Collection interface，Map family 如下：

  

• Map family 常用類別：

  1. TreeMap : keys 自動依順序排序

  2. HashTable : 執行緒安全，且 keys 和 values 不允許為 null

  3. HashMap : 非執行緒安全，且 keys 和 values 可為 null

     執行緒安全 :

     一個物件被一個執行緒使用和同時被多個執行緒使用時，行為或結果都一致，不會產生非預期結果

🍪☕ LittleTips : Set 和 Map 兩者都有可以支援排序的分支

1. 支援排序的分支起源皆以 Sorted 作為前綴。例：SortedMap 、 SortedSet (interface)
2. 實作類別都是以 Tree 為開頭。例：TreeMap 、 TreeSet

集合物件成員的排序

排序作法

如何排序物件類別，如何定義順序，一個類別可以定義多個排序標準嗎？有以下兩個介面可選擇

1. Comparable 介面 - 實作 compareTo() 方法
2. Comparator 介面 - 實作 compare() 方法

兩種方法都回傳一個整數，表示比較結果：

1. 回傳整數 = 0：兩者相等
2. 回傳整數 < 0：表示「自己（this）」**小於（數值上）**或 先於（順序上）「方法參數物件」
3. 回傳整數 > 0：表示「自己（this）」**大於（數值上）**或 後於（順序上）「方法參數物件」

1
2
3
4
5
6

Calendar today = Calendar.getInstance();
Calendar tomorrow = Calendar.getInstance();
tomorrow.add(Calendar.DATE, 1);
out.println(today.compareTo(tomorrow));   // 字串 today 先於 tomorrow，所以回傳-1
out.println("A".compareTo("B"));          // 字串"A"早於字串"B"，所以回傳-1
out.println(Integer.valueOf(5).compareTo(Integer.valueOf(6)));

使用 Comparable 介面排序

1
2
3

public interface Comparable<T> {
    public int compareTo(T o);
}

特色：

1. 支援泛型設計

2. 必須實作 compareTo() 方法，比較自己（this）和方法參數物件

3. 一個 class 只能實作一次 Comparable 介面，所以只能提供單一方式排序，可用於 TreeSet 和 TreeMap 等實作類別，或需要物件之間比較的地方

4. 決定該物件類別要以哪一個條件決定 Student 物件的排序先後，再讓該類別實作 Comparable 介面

   1. 必須提供 compareTo() 方法的內容
   2. 只能提供一種排序選擇

   1 2 3 4 5 6 7 8 9 10 11

   public class Student implements Comparable<Student> { ... @Override public int compareTo(Student s) { // use method delegation 方法委派 int sortById = Long.valueOf(this.id).compareTo(s.id); int sortByName = this.name.compareTo(s.getName()); int sortByScome = Double.valueOf(this.score).compareTO(s.score); return sortById; } }

使用 Comparator 介面排序

• 實作 Comparable interface 的類別只有提供一次 compareTo() 方法內容的機會，故只有一種排序能力

• 使用 Comparator interface 則可以提供多種選擇

  1 2 3

  public interface Comparator<T> { int compare(T o1, T o2); }

• 特色：

  1. 支援泛型設計

  2. 需實作 compare()，用以比較「第一個參數物件」和「第二個參數物件」

  3. 可藉由提供多種 Comparator 類別，達成多種排序方式。

     • 常用於搭配以下方法，以幫助 List 成員排序

       1 2 3

       public static <T> void sort(List<T> list, Comparator<? super T> c) { list.sort(c); }

       1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

       class NameSorter implements Comparator<Student> { public int compare(Student s1, Student s2) { return s1.getName().compareTo(s2.getName()); } } class ScoreSorter implements Comparator<Student> { public int compare(Student s1, Student s2) { return Double.valueOf(s1.getScore()).compareTo(s2.getScore()); } } public class TestComparator { private static void showList(List<Student> studentList) { for (int i = 0; i < studentList.size(); i++) { System.out.println("index#" + i + ": " + studentList.get(i)); } } public static void main(String[] args) { List<Student> studentList = new ArrayList<>(3); studentList.add(new Student("Thomas", 1, 3.8)); studentList.add(new Student("John", 2, 3.9)); studentList.add(new Student("George", 3, 3.4)); System.out.println("\n------ Original ------"); showList(studentList); System.out.println("\n----- Sort by name -----"); Comparator<Student> sortName = new NameSorter(); Collections.sort(studentList, sortName); showList(studentList); System.out.println("\n----- Sort by score -----"); Comparator<Student> sortScore = new ScoreSorter(); Collections.sort(studentList, sortScore); showList(studentList); } }

使用 of() 與 copyOf() 方法建立 List、Set 與 Map 物件

使用of()方法建立 List, Set, Map 物件

• 自 Java 9 開始，除了傳統使用 new 呼叫子類別建構子以建立 List, Set, Map 物件外

  • 導入靜態工廠方法 of() 來建立不可改變（immutable）的物件

    • List.of() | Set.of() | Map.of()

      1 2 3

      List<T> list = List.of(t1, t2, ...); Set<T> set = Set.of(t1, t2, ...); Map<K, V> map = Map.of(key1, value1, key2, value2, ...);

    • line 5, 15, 26 : 以 of() 建立物件後，若再嘗試新增成員（list.add(...)、set.add(...)、map.put(...)），都會拋出 java.lang.UnsupportOperationException

    • line 9, 19, 30 : 如果要將不可更改的物件轉換為可更改物件，可將其作為 ArrayList、HashSet、HashMap 等建構子的參數，重新建立可更改物件

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

      private static void createImmutablesByOf() { // List.of() List<String> list1 = List.of("i1", "i2", "i3"); try { list1.add("i4"); // line 5 : UnsupportedException } catch (Exception e) { e.printStackTrace(); } List<String> list2 = new ArrayList<>(list1); // line 9 : mutable w/ ArrayList list2.add("i4"); System.out.println(list2); // Set.of() Set<String> set1 = Set.of("i1", "i2", "i3"); try { set1.add("i4"); // line 15 : UnsupportedException } catch (Exception e) { e.printStackTrace(); } Set<String> set2 = new HashSet<>(set1); // line 19 : mutable w/ HashSet set2.add("i4"); System.out.println(set2); // Map.of() Map<String, Employee> map1 = Map.of("jim", new Employee("jim"), "duke", new Employee("duke")); try { map1.put("bill", new Employee("bill")); // line 26 : UnsupportedException } catch (Exception e) { e.printStackTrace(); } Map<String, Employee> map2 = new HashMap<>(map1); // line 30 : mutable w/ HashMap map2.put("bill", new Employee("bill")); System.out.println(map2); }

使用copyOf()方法建立 List, Set, Map 物件

• 從 Java 10 開始，又導入另一個靜態工廠方法 copyOf()，可以建立「不可改變」的「副本物件」

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  private static void createImmutablesByCopyOf() { // List.copyOf() List<String> list1 = List.of("i1", "i2", "i3"); List<String> list2 = List.copyOf(list1); // immutable copy try { list2.add("i4"); // UnsupportedOperationException } catch (Exception e) { e.printStackTrace(); } // Set.copyOf() Set<String> set1 = Set.of("i1", "i2", "i3"); Set<String> set2 = Set.copyOf(set1); // immutable copy try { set2.add("i4"); // UnsupportedOperationException } catch (Exception e) { e.printStackTrace(); } // Map.copyOf() Map<String, Employee> map1 = Map.of("jim", new Employee("jim"), "duke", new Employee("duke")); Map<String, Employee> map2 = Map.copyOf(map1); // immutable copy try { map2.put("bill", new Employee("bill")); // UnsupportedOperationException } catch (Exception e) { e.printStackTrace(); } }

使用 Arrays.asList()建立 List 物件

List 另一種以「單個元素成員」作為參數建立 List 物件的方式

1

List<T> list = Arrays.asList(t1, t2, ...);

使用 Arrays.asList() 建立的 List 物件和陣列（Array）相似，特性：

1. 長度固定，不可以新增/刪除成員（參考 line 6）

2. 可以修改成員（參考 line 4）

   1 2 3 4 5 6 7 8 9 10 11 12 13

   private static void createList() { List<String> list1 = Arrays.asList("i1", "i2", "i3"); try { list1.set(0, "iil"); // line 4 : element updatable System.out.println(list1); list1.remove(0); // line 6 : removing or adding not permitted } catch (Exception e) { e.printStackTrace(); } List<String> list2 = new ArrayList<>(list1); list2.remove(0); System.out.println(list2); }

02 例外與斷言

例外

值得信賴的程式會優雅的處理例外狀況：

1. 處理目標是「exception（例外）」，非預期狀況
2. 例外必須處理以建立可信賴的程式
3. 發生原因可能是程式 bugs
4. 發生原因可能是程式無法處理的狀況
   • 資料庫無法連線
   • 硬碟毀損

C語言發生錯誤的話，通常以回傳負值表示，例如 int x = printf("hi")

Java 則在出現錯誤時，由 JVM 拋出例外物件，不同種類的例外，有不同處理方式

• 當類別方法呼叫其他類別方法時，如果被呼叫的方法已宣告有拋出 checked exception 的風險，編譯器會要求呼叫者方法必須處理（handle）或是也宣告（declare）可能發生的問題：
  1. Handling Exception：表示必須有程式碼區塊來處理異常狀況，此時使用「try-catch」敘述
  2. Declaring Exception：在方法上註記執行可能出現的錯誤，提醒使用的方法必須處理，此時使用「throws」宣告

使用try-catch程式碼區塊

一般例外狀況

1
2
3
4
5
6
7
8
9

public static void tryCatchTest() {
    try {
        System.out.println("Opening a file...");
        InputStream in = new FileInputStream("lostFile.txt");
        System.out.println("File is opened");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

• catch程式碼區塊必須傳入 java.lang.Exception 或 java.lang.Throwable 的子類別參考

• 其中java.lang.Throwable 是例外始祖，如下：

  1 2 3 4 5

  try { // ... } catch (Exception e) { e.printStackTrace(); }

• 把 catch 當成一種方法，則後面的 () 代表要傳入的參數

• 傳入大分類的型別（父類別或介面）為多型的應用，但不適用於此，例外處理應該對症下藥

• catch 方法只讓 Java 在程式遇到錯誤時呼叫 / 傳入例外物件

• 捕捉例外後：

  1. 紀錄錯誤訊息
  2. 重試一次
  3. 嘗試其它替代方案
  4. 離開（return）或結束程式（exit）

複雜例外狀況

• 一個程式碼區塊 / 方法，必須同時處理多種可能的例外狀況：

  1. 單一「try」搭配多個「catch」：例外子類別排序應該在父類別上面，避免所有例外一開始就被例外父類別（Exception, Throwable）攔截

  2. 捕捉（catch）物件 Exception 時，盡可能捕捉最特定（specific type）的例外子類別

  3. Java Persistence API（JPA）例外大部分繼承 RuntimeException，屬 unchecked exception

     • 慣例上為不用處理的意外，但正式環境裡還是應該處理

       1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

       public void tryCatch() { try { System.out.println("Opening a file..."); InputStream in = new FileInputStream("lostFile.txt"); System.out.println("File is opened"); int data = in.read(); in.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } }

紀錄（Logging）錯誤內容

• 正式環境中，應移除 printStackTrace() 或 System.out.println(e.getMessage())此類程式碼
• 執行錯誤時，應該寫入紀錄 / 日誌檔（log file），相關函式庫
  1. Simple logging facade for Java SLF4J
  2. Apache’s Log4j
  3. Built-in java.util logging framework

使用finally敘述

• 使用外部資源，例如開啟檔案或連線資料庫，應該在不使用時關閉資源

• 如果在 try 區塊中關閉資源，可能因為執行錯誤而導致資源開了來不及關，此時可用 finally 敘述

  1. 不管是 try 或者 catch 執行結束，都一定會進入 finally 程式碼區塊

  2. 有時在 finally 區的程式碼也可能出錯，因此需要巢狀 try-catch 區塊來處理

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

     public void tryCatchFinally() { InputStream in = null; try { System.out.println("Opening a file..."); in = new FileInputStream("lostFile.txt"); System.out.println("File is opened"); int data = in.read(); in.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } finally { try { if (in != null) in.close(); // try to close file } catch (IOException e) { System.out.println("Failed to close file"); } } }

使用 try-with-resources 程式碼區塊和 AutoCloseable 介面

使用 try-with-resources 敘述

• Java 7 提供新的 try-with-resources 敘述，可自動關閉被開啟的「資源（resources）」

  1 2 3 4

  try ( 宣告並開啟資源 [; 宣告並開啟其它資源 ...] ) { // ... } // 在 try 程式碼區塊之後，資源將自動關閉

  1. 這裡定義的資源，必須為實作 java.lang.AutoCloseable 介面的類別

  2. 如果要開多個資源，可以使用「;」做區隔

  3. 自動關閉的順序將和使用資源的開啟順序相反

     1 2 3 4 5 6 7 8 9 10 11 12 13 14

     public void tryWithResource() { System.out.println("Opening a file..."); try (InputStream in = new FileInputStream("lostFile.txt")) { // System.out.println("File is opened"); int data = in.read(); in.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } }

比較 tryCatchFinally 與 tryWithResource，可以發現：

1. 移除 finally 程式碼區塊，如前範例行 16 - 23
2. 使用 try-with-resource 宣告要開啟的資源

認識 AutoCloseable介面

1

public abstract class InputStream implements Closeable {

1

public interface Closeable extends AutoCloseable {

• 資源（resource）要藉由 `try-with-resources‵ 敘述開啟和自動關閉，必須實作以下兩者任一

  1. 介面 java.lang.AutoCloseable

     • Java 7 新增

     • 唯一的抽象方法 close() 會拋出 Exception 物件

       1 2 3

       public interface AutoCloseable { void close() throws Exception; }

  2. 介面 java.io.Closeable

     • 早期的 Java 版本就存在，在 Java 7 中修改使其繼承介面 AutoCloseable

     • 唯一的抽象方法 close() 會拋出 IOException 物件

       1 2 3

       public interface Closeable extends AutoCloseable { public void close() throws IOException; }

Idempotent method - 即使重複執行多次，也不會有副作用（side effects）產生

• java.io.Closeable 的 close() 方法必須滿足 idempotent 要求

• java.lang.AutoCloseable 並未一致要求實作之 close() 必須比照辦理

  • 即便如此仍應該要做到反覆執行多次都沒有副作用產生

    1 2 3 4

    // 若資源為關閉（以resource == null 判定） If (resource != null) { // 關閉資源，並使 resource = null }

Suppressed Exceptions

使用 try-with-resource 也衍伸出新的例外 exception 處理問題必須注意：

1. Java 開啟資源時拋出例外，未成功開啟資源
   • 程式碼直接跳到 catch 區，只拋出一個例外
2. Java 成功開啟資源，但在 try 區拋出例外，在背景關閉資源時又拋出例外
   • 共產生 2 個例外
   • catch 區必須同時接收 2 個例外物件 衍伸問題
3. Java 成功開啟資源，try 區塊內任務成功執行，但在關閉資源時出錯
   • 和一般情況一樣，只拋出 1 個例外

• 當有兩個例外類別被先後拋出，Java會將 後發生，同時和關閉資源有關 的例外物件，隱匿/擠壓（suppressed）到「先發生、也是在 try 區塊造成」的例外物件裡，使其可被保留

• Java 會將資源相關的例外隱匿 / 擠壓進程式碼的例外裡，只要知道如何將 suppressed 例外物件取出（參以下 line 3 ~ line 5）

  1 2 3 4 5 6

  } catch(Exception e) { System.out.println(e.getMessage()); for (Throwable t : e.getSuppressed()) { // line 3 System.out.println(t.getMessage()); } // line 5 }

• 對例外物件呼叫 e.getSuppressed() 方法時，可回傳一個 Throwable 陣列

  • 在背景被擠壓 / 隱匿的例外，即使再多都能被保存並取出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

class TryException extends Exception {
}
class FinallyException extends Exception {
}
public class SuppressedExceptions {
    public static void main(String[] args) {
        before7();
        after7();
    }
    private static void before7() {
        try {
            try {
                throw new TryException();   // This is lost.
            } finally {
                throw new FinallyException();
            }
        } catch (Exception e) {
            System.out.println("before 7: " + e.getClass());
        }
    }
    private static void after7() {
        try {
            Throwable t = null; // 保留第一個拋出的例外物件 TryException (1/2)
            try {
                throw new TryException();
            } catch (Exception e) {
                t = e;  // 保留第一個拋出的例外物件 TryException (2/2)
            } finally {
                FinallyException fe = new FinallyException();
                if (t != null) {
                    t.addSuppressed(fe); 
                    // 將 finallyException 隱匿至 t, 再拋出 tryException
                    throw t;
                } else {
                    throw fe; // 若無 tryException, 單獨拋出 finallyException
                }
            }
        } catch (Throwable e) {
            System.out.println("after7: " + e.getClass());
            for (Throwable t : e.getSuppressed()) {
                System.out.println("after7: " + t.getClass());
            }
        }
    }
}

使用 multi-catch 敘述

不建議直接捕捉例外的父類別，如 Exception 或 Throwable，因為：

1. 每種意外的處理方式應該不同
2. 要清楚知道究竟有多少個例外可能產生

如果每種例外處理方式皆相同，則可以使用 Java 7 multi-catch 敘述，優點：

1. 可清楚知道究竟有多少例外可能拋出
2. 多種例外，同一種方式處理，簡潔化程式碼
3. 不同例外以「|」區隔時，前後例外必須「沒有繼承關係」
   • 例如 Exception class 不能和以 multi-catch 敘述聚集的例外類別放一起

使用 throws 宣告

• 在類別方法上宣告 throws ExceptionTypes，讓呼叫該方法的 caller 處理

• 覆寫子類別方法時，若父類別方法宣告拋出例外

  1. checked exception，子類別覆寫方法拋出的例外必須：

     • 例外型別必須相同，或者為其子類別（覆寫後有精進）
     • 數量相同或更少（表示問題已被處理 improved）

  2. unchecked exception：子類別覆寫方法時可不予理會，例如 RuntimeException

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

     abstract class Father { abstract void fatherMethod1() throws IOException; abstract void fatherMethod2() throws RuntimeException; abstract void fatherMethod3() throws SQLException; } class Child extends Father { @Override void fatherMethod1() throws IOException, FileNotFoundException { } // FileNotFoundException 為 IOException 子類別，未超出 IOException 範圍 @Override void fatherMethod2() { } // 父類別 RuntimeException-UncheckException，子類別可以不處理 @Override void fatherMethod3() { } // SQLException 在方法內使用 try-catch 敘述，妥善處理不再拋出例外 }

建立客製的 Exception

客製化的例外類別

建立客製化的例外子類別 DAOException，繼承 class Exception

1
2
3
4
5
6
7
8

public class DAOException extends Exception {
    public DAOException() {
        super();
    }
    public DAOException(String message) {
        super(message);
    }
}

• 標準 Java 不會主動拋出客製化例外子類別，必須先捕捉標準的例外類別，再拋出客製化例外子類別

  1 2 3 4 5 6

  try { // some codes that might cause error } catch (Exception e) { e.printStackTrace(); throw new DAOException(); }

客製化包裹例外類別（Wrapper Exception）

• 如果希望再拋出的客製化例外子類別也能保留最初被捕捉的例外類別訊息，可使用 wrapper 例外類別，將最初的例外類別包裹在客製例外類別中

  • 設計客製例外類別

    1 2 3 4 5 6 7 8

    public class DAOException extends Exception { public DAOException(Throwable cause) { super(cause); } public DAOException(String msg, Throwable cause) { super(msg, cause); } }

  • 將捕捉真實例外類別作為客製例外類別的建構子參數

    1 2 3 4 5 6

    try { // some codes might error } catch (Exception e) { e.printStackTrace(); throw new DAOException(e); }

  • 使用 getCause() 方法取出被包裹的原始例外物件

    1 2 3 4 5

    try { // some codes might cause error } catch (DAOException e) { Throwable t = e.getCause(); }

  • 使用包裹例外型別提供解決範例

    1. 先設計介面的抽象方法並宣告拋出 DAOException：

       1	Employee findById(int id) throws DAOException;

    2. File-based 的方法實作方式：

       1 2 3 4 5 6 7

       public Employee findById(int id) throws DAOException { try { } catch () { throw new DAOException(e); } }

    3. JDBC-based 的方法實作方式：

       1 2 3 4 5 6 7

       public Employee findById(int id) throws DAOException { try { return getEmployeeFromDatabase(int id); } catch (SQLException e) { throw new DAOException(e); } }

斷言

Assertions 的簡介和語法

• 斷言若失敗被認為是嚴重的問題，表示程式執行結果和預期有出入
• 程式會拋出 AssertionError 並中斷程式執行，AssertionError 為 unchecked exception。

1
2
3

// Syntax
assert <boolean_expression>;
assert <boolean_expression> : <detail_expression>;

1. <boolean_expression> 若為 false，將拋出 AssertionError
2. <detail_expression> 為捕捉 AssertionError 後呼叫 getMessage() 方法回傳的子串

Assertions 使用情境

• 使用 Assertions 來驗證假設和方法的不變量（不會改變的數值或結果，invariant），通常情況：
  1. 內部的不變量（internal invariants）
  2. 流程控管的不變量（control flow invariants）
  3. 事後的狀態和類別不變量（post-conditions & class invariants）

Assertions 的使用注意事項

• Assertions 的檢查預設關閉（disabled），使用前必須開啟

• 要避免不當的使用方式：

  1. 不可用於類別方法的參數輸入檢查

  2. 不可影響程式正常流程

     1 2 3

     // 將物件的生成放在 assertion 的判斷敘述中 SomeType s = null; assert (s = new SomeType()) != null;

Assertions 的使用

內部的不變量 internal invariants

• 在 else block 加上 assert == 0，使 x 無負值的可能

  1 2 3 4 5

  if (x > 0) { // do if x > 0 } else { assert (x == 0); }

流程控管的不變量 control flow invariants

• 為始 switch case 不可能進入 default block，直接在 default block 裡使用 assert false

  • 表示程式進到此不用再以 boolean 表達式判斷，而是馬上拋出 AssertError

    1 2 3 4 5 6 7 8 9 10 11 12 13

    private static void controlFlowInvariants(Gender g) { switch (g) { case MALE: // do something break; case FEMALE: // do something break; default: assert false: "Unknown gender!!"; break; } }

事後的狀態和類別不變量 post-conditions & class invariants

• 無論類別欄位經過任何改變，都應該能通過方法 rule() 的檢驗

  1 2 3 4 5 6 7 8 9 10

  class MyTime { int hours; int minutes; int seconds; void rule() { assert(0 <= hours && hours < 24); assert (0 <= minutes && minutes < 60); assert (0 <= seconds && seconds < 60); } }

Assertions 的開啟與關閉

• Assertions 預設是關閉，關閉後完全不會執行，和註解（comment）類似，不影響效能

  java -enableassertions HelloWord
  java -ea HelloWorld
  

• -ea即是 -enableassertions之縮寫

• 若在 -ea 後加上其它選項，可控制 Assertions 的啟用只在某個 package 或 class

  Enable and Disable Assertions

03 輸入與輸出

I/O 基礎

• 當輸入/輸出行為發生時，好比串流（stream）的流動，流入或流出某個地方
• 串流需要有來源及目的，ex. 主控台視窗（console）、檔案、資料庫、網路、其它程式

何謂 I/O

基本認知：

1. 資料的進出像是水流 / 串流
   • 來源流向目的，具有方向性，Java 中稱之為 stream (串流)
   • 流動內容主要分為「位元（byte）」和「字元（character）」
2. 水流的流動，若提供管道，稱為 channel，若使用 channel 支援 I/O 會更有效率

以 Java 程式為區分基準

1. 輸入串流 | 來源串流（input stream, source stream）

   

2. 輸出串流 | 目的串流（output stream, sink stream）

   

以程式開發最常用三種端點區分

1. 檔案（files）和目錄（directories）
2. 主控台（console）：標準輸入（standard-in）和標準輸出（standard-out）
3. Socket 程式（連線遠端系統，需指定 port 通訊）

處理串流的類別

依串流內的資料分類、流動方向、處理類別分為四個抽象類別：

Class InputStream

Class OutputStream

Class Reader

Class Writer

串流類別的串接

使用 java.io.File 類別

java.io.File 常用方法：

由主控台讀寫資料

主控台的 I/O

java.lang.System 類別裡的三個 static 欄位

使用標準輸出方法

• println() 輸出換行符、print()不輸出換行符號
• 以上兩方法對大部分基本型別以及參考型別都有多載方法支援
  • boolean, char, int, long, float, double、char[], Object, String
  • 其它參考型別則呼叫該物件的 toString() 方法

java.io.Console 類別介紹

• 除了使用前述 System.in 取得主控台標準輸入外，也可以用 java.io.Console 物件

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  public class ConsoleInput { public static void main(String[] args) { Console cons = System.console(); // 使用 System.console() 方法取得 Console 物件 boolean userValid = false; if (cons != null) { String account; String passwd; do { account = cons.readLine("%s", "Account: "); // readline() 可取得指令列輸入的資料 passwd = new String(cons.readPassword("%s", "Password: ")); // readPassword() 除了可以取得指令列輸入的資料， // 還能隱藏使用者輸入內容 if (account.equals("joanna") && passwd.equals("password")) { System.out.println("Correct! System quits!"); userValid = true; } else { System.out.println("Wrong! Try again!"); } } while (!userValid); // 後測式迴圈：先輸入再驗證，失敗繼續，成功終止 } } }

  

Channel I/O

• Channel : 可以指兩個設備之間傳送資訊經過的通路或連接
  • 導入於 JDK 1.4，屬於 java.nio package
  • 可以一次大量讀入位元和字元，不需要以迴圈每次讀取少量內容
  • 程式更簡潔，程式效能更好

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class CopyByteChannel {
	public static void main(String[] args) {
		String source = "", target = "";
		try (FileChannel in = new FileInputStream(source).getChannel();
				FileChannel out = new FileOutputStream(target).getChannel()) {
			ByteBuffer buff = ByteBuffer.allocate((int) in.size());
             // 建立和 source 檔案 size 大小相同的 ByteBuffer 物件
			in.read(buff);
             // 將實體檔案一次全數讀入到 ByteBuffer 物件中
			buff.position(0);
             // 將 ByteBuffer 裡的標示位置移到最前面
			out.write(buff);
       /* 將 ByteBuffer 裡的資料全數輸出至 FileChannel out，再由其輸出為檔案
          因為 FileChannel 的 read() 和 write() 方法都是透過 ByteBuffer 物件一次搞定
          所以不用迴圈（loop）分次處理 */
		} catch (FileNotFoundException f) {
			f.printStackTrace();
		} catch (IOException i) {
			i.printStackTrace();
		}
	}
}

使用序列化技術讀寫物件

Java 裡的資料保存 Persistence

將資料儲存於永久性的儲存硬體中，稱為「persistence」

1. 支援 persistence 的 Java 物件可儲存於本機硬體，或經由網路到另一個硬體裝置
   • 未支援 persistence 的 Java 物件只能存活於執行中的 JVM
2. 序列化 serialization：Java 將記憶體中的物件狀態儲存於硬體，成為「實體檔案」的標準機制
   • 未來可用來建構物件的副本或是還原物件狀態
3. 支援序列化的物件必須實作 java.io.Serializable 介面

• 該介面是一個「maker interface」，沒有任何需要實作的方法
• 類別實作此介面只是讓 Java 知道其物件有具備序列化的能力，具體序列化步驟由 Java 掌控

序列化和物件圖譜

• 當物件被序列化時，只有「欄位值」會被保留
  • 欄位值包含資料，也包含物件的狀態
  • 若物件的該欄位是參考型別，且被參考的物件也支援序列化，則該欄位物件也會一併被序列化
• 物件圖譜 object graphs：
  • 物件欄位參照其它物件，被參照的物件又可以再參照更多物件…所形成的樹狀結構

不需要參加序列化的欄位

• 物件序列化時，預設所有欄位都會一併進行序列化

• 如果欄位所屬類別沒有實作 java.io.Serializable，會中斷執行並丟出例外 NotSerializableException

• 若物件欄位只是記錄當下系統狀態的某些資訊（ex. 目前時間），屬於「短暫 transient」資訊

  • 不需要再序列化過程中被保留
  • 重建副本時也不需要回復
  • 此類欄位不需要參與序列化流程，可以加上「transient」宣告

• 宣告「static」的欄位和物件狀態無關，其值在物件序列化過程中也不會被保留

  1 2 3 4 5

  public class Order implements Serializable { private Set<Shirt> shirts = new HashSet<>(); static int staticField = 100; // static transient int transientField = 100; // transient }

  • 宣告 transient 以及 static 的欄位在「反序列化 / 還原」程序時
    1. static : 會得到類別內原本定義的宣告值
    2. transient : 會得到該型態的預設值

定義物件保存的版本號碼

• 序列化：保留物件「當下狀態（欄位值）」，並未保留類別架構

• 反序列化：將「過去物件某個狀態」，搭配「目前類別架構」進行還原

  • 若還原時發現「過去物件狀態」和「目前類別架構」不一致，可能產生不預期的問題或錯誤

    • 過去某欄位現在已經不存在
    • 類別後來新增必要欄位，序列化卻沒有該欄位

  • 為了能夠使序列化後的檔案可以順利的被反序列化還原成物件：

    1. 在可序列化之類別定義一個欄位 serialVersionUID 作為版本控管號碼

       • 每次增減類別內欄位時，都應該同步修改版本號碼並且記錄

       • 版本控管號碼必須宣告為 static 且 long

         private static final long serialVersionUID = 1L;

    2. InvalidClassException 預先保護機制

       • 假設目前版本號為 1，序列化後得到的檔案內存版本也會是 1
       • 後來類別增減了欄位，版本修改為 2
       • 如果以「版本#2的最新類別定義」來還原「序列化時版本#1的檔案」會拋出上述錯誤

    3. 若類別實作 Serializable 介面，但未宣告serialVersionUID

       • Java 預設將主動宣告並提供欄位值，該值將考慮開發環境因素（IDE工具或Java版本）計算出一個複雜的長整數

         private static final long serialVersionUID =3696676879791539369L;

       • 此長整數在每次編譯階段，即使只是某方法內字串微調，也可能因為環境再改變而自動改變版本號碼

       • 可能導致先前序列化的檔案因為版本號改變，而無法還原回物件

       • 建議開發者應該自己宣告 serialVersionUID 欄位

…

序列化和反序列化範例

以下範例將物件序列化產出檔案，再將檔案還原回物件，特殊情境：

• class Order 底下含數個 class Shirt(s)，其中 Shirt(s) 類別內的價錢欄位會因時因地改變，序列化過程中不需要特別保存，以 transient 宣告
• Java 給物件可以控制自身序列化和反序列化的流程
  • 序列化時可以額外寫入 java.util.Date物件，在反序列化的時候讀出，可知進行序列化時間點
• 反序列化時，希望 Shirt(s) 類別內的價錢欄位可以參考成本價，再加上 50 元管銷費用

1. class Shirt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class Shirt implements Serializable {

	private static final long serialVersionUID = 1L;
	private String brand;
	private int quantity;
	private double cost;
	private transient double price;

	public Shirt(String brand, int quantity, double cost) {
		this.brand = brand;
		this.quantity = quantity;
		this.cost = cost;
		this.price = 2 * cost;
	}

	// This method is called post-serialization
    // 要修改Java反序列化(將物件自檔案中讀出)的流程，必須定義本方法
	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        // ois.defaultReadObject() 是物件原本的反序列化流程，仍須呼叫此
		ois.defaultReadObject();
		// perform other initiliazation 將檔案還原成物件後，price欄位+50元
		this.price = this.cost + 50;
	}

	@Override
	public String toString() {
		return "Shirt: " + this.brand + "\n" 
				+ "Quantity: " + this.quantity + "\n" 
				+ "Cost: " + this.cost + "\n"
				+ "Price: " + this.price + "\n"
				+ "------------------\n";
	}
}

2. class Order

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44