泛型

import java.util.ArrayList; import java.util.List;

/** raw type 的執行期炸彈：編譯器閉嘴，執行期爆炸 */ public class RawTypeDanger

public static void main(String[] args)

// raw type：不帶型別參數的集合，什麼都能放 List names = new ArrayList(); names.add("小明"); names.add(42); // 整數也放得進去，編譯器只給警告

for (Object obj : names) // 取出時必須自己轉型：輪到 42 的時候當場爆炸 String name = (String) obj; System.out.println("名字長度：" + name.length());

/** * 泛型類別 Box：型別參數 T 是「型別的佔位符」， * 等到使用的那一刻才決定 T 是什麼。 */ class Box<T>

private T content; // 欄位的型別用型別參數表示

/** 放入內容 */ public void put(T content) this.content = content;

/** 取出內容：回傳型別就是 T，呼叫端完全不必轉型 */ public T get() return content;

/** Pair：兩個型別參數（K 與 V）的泛型類別 */ class Pair<K, V>

private final K key; private final V value;

public Pair(K key, V value) this.key = key; this.value = value;

public K getKey() return key;

public V getValue() return value;

@Override public String toString() return "(" + key + ", " + value + ")";

/** 使用泛型類別 */ public class BoxDemo

public static void main(String[] args)

// T 指定為 String：put 只收 String，get 直接回傳 String Box<String> gift = new Box<>(); // 菱形運算子：右側型別可省略 gift.put("音樂盒"); String content = gift.get(); // 不需要 (String) 轉型 System.out.println("盒子裡是：" + content);

// gift.put(42); // 編譯錯誤：42 不是 String，錯誤提前現形

// K 是 String、V 是 Integer Pair<String, Integer> entry = new Pair<>("身高", 175); System.out.println(entry.getKey() + "：" + entry.getValue()); System.out.println("完整輸出：" + entry);

import java.util.List;

/** 泛型方法：型別參數宣告在回傳型別「之前」 */ public class GenericMethodDemo

/** 交換陣列中兩個位置的元素：對任何參考型別都適用 */ static <T> void swap(T[] array, int i, int j) T tmp = array[i]; // 型別參數讓暫存變數的型別正確 array[i] = array[j]; array[j] = tmp;

/** 回傳清單的第一個元素：回傳型別跟著傳入的清單走 */ static <T> T first(List<T> list) return list.get(0);

public static void main(String[] args)

String[] words = "甲", "乙", "丙" ; swap(words, 0, 2); // 型別推斷：T 自動推為 String System.out.println(String.join("", words));

Integer[] nums = 1, 2, 3 ; // 也可以明確指定型別參數（通常不必，編譯器推得出來） GenericMethodDemo.<Integer>swap(nums, 0, 1); System.out.println(nums[0] + ", " + nums[1] + ", " + nums[2]);

List<Double> prices = List.of(19.99, 5.5); double p = first(prices); // T 推斷為 Double，再自動拆箱 System.out.println("第一個價格：" + p);

/** 有界型別參數：T 必須「會比較大小」才能找最大值 */ public class BoundedTypeDemo

/** * 回傳三者中的最大值。 * 界限「extends Comparable」保證 T 一定實作了 Comparable， * 否則方法本體根本無法呼叫 compareTo。 */ static <T extends Comparable<T>> T max(T a, T b, T c) T result = a; // 先假設 a 最大 if (b.compareTo(result) > 0) // 界限保證 compareTo 存在 result = b; if (c.compareTo(result) > 0) result = c; return result;

public static void main(String[] args) // Integer 與 String 都實作了 Comparable，直接可用 System.out.println("最大整數：" + max(3, 9, 5)); System.out.println("最大字串：" + max("pear", "apple", "kiwi")); // max(new Object(), ...)：編譯錯誤，Object 沒實作 Comparable

import java.util.ArrayList; import java.util.List;

/** 萬用字元三兄弟：無界 ?、上界 ? extends、下界 ? super */ public class WildcardDemo

/** 無界萬用字元：任何 List 都能收，但元素只能當 Object 讀 */ static void printAll(List<?> list) for (Object item : list) // 只知道它「是個物件」 System.out.print(item + " "); System.out.println();

/** 上界：收 Number 或其子型別的清單——只能讀（生產者） */ static double sum(List<? extends Number> list) double total = 0; for (Number n : list) // 讀出來保證是 Number total += n.doubleValue(); // list.add(1); // 編譯錯誤：實際型別未知，寫入不安全 return total;

/** 下界：收 Integer 或其父型別的清單——可以安全寫入（消費者） */ static void fillCount(List<? super Integer> list, int n) for (int i = 1; i <= n; i++) list.add(i); // 寫入 Integer 一定相容

public static void main(String[] args)

List<Integer> ints = List.of(1, 2, 3); List<Double> doubles = List.of(0.5, 1.5);

printAll(ints); // List<?> 什麼清單都能印 printAll(doubles);

// 上界：Integer、Double 的清單都可以傳進 sum System.out.println("整數和：" + sum(ints)); System.out.println("小數和：" + sum(doubles));

// 下界：List<Number>（Integer 的父型別清單）可以傳入 List<Number> numbers = new ArrayList<>(); fillCount(numbers, 3); System.out.println("寫入結果：" + numbers);

/** 把來源清單的元素全部複製到目的清單 */ static <T> void copy(List<? super T> dst, List<? extends T> src) for (T item : src) // src 是生產者：從它讀出 T（extends） dst.add(item); // dst 是消費者：把 T 寫進它（super）

// 呼叫範例：來源是 List<Integer>，目的地可以是 List<Number> // List<Number> dst = new ArrayList<>(); // copy(dst, List.of(1, 2, 3)); // T 推斷為 Integer

/** 陣列是協變的：編譯器放行，執行期才發現放錯東西 */ public class CovarianceDemo

public static void main(String[] args)

// 陣列：Integer[] 可以指派給 Number[]（協變） Number[] numbers = new Integer[2]; numbers[0] = 1; // OK：放 Integer try numbers[1] = 3.14; // 編譯過關，執行期才被抓包 catch (ArrayStoreException e) System.out.println("執行期例外：" + e);

// 泛型：List<Integer> 不能指派給 List<Number>（不變性） // List<Number> list = new ArrayList<Integer>(); // 編譯錯誤 // 這正是泛型的初衷：把錯誤攔在編譯期，而不是執行期 System.out.println("陣列內容：" + numbers[0] + ", " + numbers[1]);

import java.util.ArrayList; import java.util.List;

/** 型別抹除的可觀察證據 */ public class ErasureDemo

public static void main(String[] args)

List<String> strings = new ArrayList<>(); List<Integer> integers = new ArrayList<>();

// 執行期兩者是同一個類別物件：型別參數已被抹除 System.out.println(strings.getClass() == integers.getClass()); System.out.println(strings.getClass().getName());

import java.util.ArrayList; import java.util.List;

/** * 型別安全的泛型堆疊（LIFO：後進先出）。 * 內部用 ArrayList 保存元素，尾端視為堆疊頂端。 */ class GenericStack<E>

// 組合而非繼承：內部細節不外洩，公開介面完全由我們決定 private final List<E> elements = new ArrayList<>();

/** 推入：把元素放上堆疊頂端 */ public void push(E element) elements.add(element); // 加到尾端就是頂端

/** 彈出：移除並回傳頂端元素 */ public E pop() if (isEmpty()) // 空堆疊還要彈出是呼叫端的錯：拋 unchecked 例外 throw new IllegalStateException("堆疊是空的"); return elements.remove(elements.size() - 1);

/** 偷看：回傳頂端元素但不移除 */ public E peek() if (isEmpty()) throw new IllegalStateException("堆疊是空的"); return elements.get(elements.size() - 1);

/** 是否為空 */ public boolean isEmpty() return elements.isEmpty();

/** 目前元素個數 */ public int size() return elements.size();

/** 測試泛型堆疊：同一份程式碼服務所有元素型別 */ public class GenericStackDemo

public static void main(String[] args)

// 模擬瀏覽器的「上一頁」歷史堆疊 GenericStack<String> history = new GenericStack<>(); history.push("首頁"); history.push("商品列表"); history.push("商品明細");

System.out.println("目前頁面：" + history.peek()); System.out.println("頁面數量：" + history.size());

// 連續按兩次上一頁 System.out.println("返回：" + history.pop()); System.out.println("返回：" + history.pop()); System.out.println("目前頁面：" + history.peek());

// 換一種元素型別：不需要改動 GenericStack 的任何一行 GenericStack<Integer> numbers = new GenericStack<>(); numbers.push(10); numbers.push(20); System.out.println("整數堆疊頂端：" + numbers.pop()); System.out.println("清空了嗎：" + numbers.isEmpty());