## 泛型異常 由于擦除的原因，**catch** 語句不能捕獲泛型類型的異常，因為在編譯期和運行時都必須知道異常的確切類型。泛型類也不能直接或間接繼承自 **Throwable**（這將進一步阻止你去定義不能捕獲的泛型異常）。 但是，類型參數可能會在一個方法的 **throws** 子句中用到。這使得你可以編寫隨檢查型異常類型變化的泛型代碼： ```java // generics/ThrowGenericException.java import java.util.*; interface Processor<T, E extends Exception> { void process(List<T> resultCollector) throws E; } class ProcessRunner<T, E extends Exception> extends ArrayList<Processor<T, E>> { List<T> processAll() throws E { List<T> resultCollector = new ArrayList<>(); for(Processor<T, E> processor : this) processor.process(resultCollector); return resultCollector; } } class Failure1 extends Exception {} class Processor1 implements Processor<String, Failure1> { static int count = 3; @Override public void process(List<String> resultCollector) throws Failure1 { if(count-- > 1) resultCollector.add("Hep!"); else resultCollector.add("Ho!"); if(count < 0) throw new Failure1(); } } class Failure2 extends Exception {} class Processor2 implements Processor<Integer, Failure2> { static int count = 2; @Override public void process(List<Integer> resultCollector) throws Failure2 { if(count-- == 0) resultCollector.add(47); else { resultCollector.add(11); } if(count < 0) throw new Failure2(); } } public class ThrowGenericException { public static void main(String[] args) { ProcessRunner<String, Failure1> runner = new ProcessRunner<>(); for(int i = 0; i < 3; i++) runner.add(new Processor1()); try { System.out.println(runner.processAll()); } catch(Failure1 e) { System.out.println(e); } ProcessRunner<Integer, Failure2> runner2 = new ProcessRunner<>(); for(int i = 0; i < 3; i++) runner2.add(new Processor2()); try { System.out.println(runner2.processAll()); } catch(Failure2 e) { System.out.println(e); } } } /* Output: [Hep!, Hep!, Ho!] Failure2 */ ``` **Processor** 執行 `process()` 方法，并且可能會拋出具有類型 **E** 的異常。`process()` 的結果存儲在 `List<T>resultCollector` 中（這被稱為*收集參數*）。**ProcessRunner** 有一個 `processAll()` 方法，它會在所持有的每個 **Process** 對象執行，并返回 **resultCollector** 。 如果不能參數化所拋出的異常，那么由于檢查型異常的緣故，將不能編寫出這種泛化的代碼。