深入理解java異常處理機制

1. 引子

　　try…catch…finally恐怕是大家再熟悉不過的語句了，而且感覺用起來也是很簡單，邏輯上似乎也是很容易理解。不過，我親自體驗的「教訓」告訴我，這個東西可不是想像中的那麼簡單、聽話。不相信？那你看看下面的程式碼，「猜猜」它執行後的結果會是什麼？不要往後看答案、也不允許執行程式碼看真正答案哦。如果你的答案是正確，那這篇文章你就不用浪費時間看啦。

package Test; 
   
public class TestException { 
    public TestException() { 
    } 
   
    boolean testEx() throws Exception { 
        boolean ret = true; 
        try { 
            ret = testEx1(); 
        } catch (Exception e) { 
            System.out.println("testEx, catch exception"); 
            ret = false; 
            throw e; 
        } finally { 
            System.out.println("testEx, finally; return value=" + ret); 
            return ret; 
        } 
    } 
   
    boolean testEx1() throws Exception { 
        boolean ret = true; 
        try { 
            ret = testEx2(); 
            if (!ret) { 
                return false; 
            } 
            System.out.println("testEx1, at the end of try"); 
            return ret; 
        } catch (Exception e) { 
            System.out.println("testEx1, catch exception"); 
            ret = false; 
            throw e; 
        } finally { 
            System.out.println("testEx1, finally; return value=" + ret); 
            return ret; 
        } 
    } 
   
    boolean testEx2() throws Exception { 
        boolean ret = true; 
        try { 
            int b = 12; 
            int c; 
            for (int i = 2; i >= -2; i--) { 
                c = b / i; 
                System.out.println("i=" + i); 
            } 
            return true; 
        } catch (Exception e) { 
            System.out.println("testEx2, catch exception"); 
            ret = false; 
            throw e; 
        } finally { 
            System.out.println("testEx2, finally; return value=" + ret); 
            return ret; 
        } 
    } 
   
    public static void main(String[] args) { 
        TestException testException1 = new TestException(); 
        try { 
            testException1.testEx(); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
}

　你的答案是什麼？是下面的答案嗎？

　　i=2
　　i=1
　　testEx2, catch exception
　　testEx2, finally; return value=falseception test.test. alse
　　testEx, catch exception
　　testEx, finally; return value= false

　　如果你的答案真的如上面所說，那麼你錯啦。 ^_^，那就建議你仔細看這篇文章或拿上面的程式碼按各種不同的情況修改、執行、測試，你會發現有很多事情不是原來想像中的那麼簡單的。現在公佈正確答案：

　　i=2

　　i=1

　　testEx2, catch exception
　　testEx2, finally; return value=falsetest
　　testEx2, finally; return value=falsetest🀎 finally; return value=false

　　注意說明：

　　finally語句區塊不應該出現應該會出現return。上面的return ret最好是其他語句來處理相關邏輯。

　　2.JAVA異常

　　異常指不期而至的各種狀況，如：檔案找不到、網路連線失敗、非法參數等。異常是一個事件，它發生在程式運作期間，幹擾了正常的指令流程。 Java通 過API中Throwable類別的眾多子類別描述各種不同的異常。因而，Java異常都是對象，是Throwable子類別的實例，描述了出​​現在一段編碼中的 錯誤條件。當條件生成時，錯誤將引發異常。

　　Java異常類別層次結構圖：

在 Java 中，所有的異常都有一個共同的祖先 Throwable（可拋出）。 Throwable 指定程式碼中可用異常傳播機制透過 Java 應用程式傳輸的任何問題的共通性。

　　Throwable： 有兩個重要的子類別：Exception（異常）和 Error（錯誤），二者都是 Java 異常處理的重要子類，各自都包含大量子類別。

　　Error（錯誤）:是程式無法處理的錯誤，表示執行應用程式中較嚴重問題。大多數錯誤與程式碼編寫者執行的操作無關，而表示程式碼執行時期 JVM（Java 虛擬機）出現的問題。例如，Java虛擬機器運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的記憶體資源時，就會出現 OutOfMemoryError。這些異常發生時，Java虛擬機器（JVM）一般會選擇執行緒終止。

　　這些錯誤表示故障發生於虛擬機器本身、或發生在虛擬機器試圖執行應用時，如Java虛擬機器運作錯誤（Virtual MachineError）、類別定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因為它們在應用程式的控制和處理能力之 外，而且絕大多數是程式執行時不允許出現的狀況。對於設計合理的應用程式來說，即使確實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。在 Java中，錯誤透過Error的子類別來描述。

　　Exception（異常）:是程式本身可以處理的異常。

　　Exception 類別有一個重要的子類別 RuntimeException。 RuntimeException 類別及其子類別表示「JVM 常用操作」引發的錯誤。例如，若試圖使用空值物件參考、除數為零或陣列越界，則分別引發執行時期例外狀況（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。

　　注意：異常和錯誤的區別：異常能被程式本身可以處理，錯誤是無法處理。

　　通常，Java的異常(包括Exception和Error)分為可查的異常（checked exceptions）和不可查的異常（unchecked exceptions）。

　　可查異常（編譯器要求必須處置的異常）：正確的程式在運作中，很容易出現的、情理可容的異常狀況。可查異常雖然是異常狀況，但在某種程度上它的發生是可以預期的，而且一旦發生這種異常狀況，就必須採取某種方式進行處理。

　　除了RuntimeException及其子類別以外，其他的Exception類別及其子類別都屬於可查異常。這種異常的特徵是Java編譯器會檢查它，也就是說，當程式中可能出現這類異常，要么用try-catch語句捕獲它，要么用throws子句聲明拋出它，否則編譯不會通過。

　　不可查異常(編譯器不要求強制處置的異常)：包含運行時異常（RuntimeException與其子類別）和錯誤（Error）。

　　Exception 這種異常分兩大類運行時異常和非運行時異常(編譯異常)。程序中應盡可能去處理這些異常。

　　運行時異常：都是RuntimeException類別及其子類別異常，如NullPointerException(空指標異常)、IndexOutOfBoundsException(下標越界異常)等，這些異常是不檢查異常，程式中可以選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇捕獲處理，也可以不選擇處理。這些異常一般是由程式邏輯錯誤引起的，程式應該從邏輯角度盡可能避免這類異常的發生。

　　運行時異常的特點是Java編譯器不會檢查它，也就是說，當程式中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會編譯通過。

　　非運行時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬於Exception類別及其子類別。從程式語法角度講是必須進行處理的異常，如果不處理，程式就不能編譯通過。如IOException、SQLException等以及使用者自訂的Exception異常，一般情況下不自訂檢查異常。

　　3.處理異常機制

　　在 Java 應用程式中，異常處理機制為：拋出異常，捕捉異常。

　　拋出異常：當一個方法出現錯誤引發異常時，方法創建異常對象並交付運行時系統，異常對像中包含了異常類型和異常出現時的程序狀態等異常資訊。運行時系統負責尋找處置異常的程式碼並執行。

　　捕獲異常：在方法拋出異常之後，運行時系統將轉換為尋找合適的異常處理器（exception handler）。潛在的異常處理器是異常發生時依序存留在呼叫堆疊中的方法的集合。當異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即為合適 的異常處理器。運行時系統從發生異常的方法開始，依序回查呼叫堆疊中的方法，直到找到含有合適異常處理器的方法並執行。當運行時系統遍歷調用堆疊而未找到合適 的異常處理器，則運行時系統終止。同時，意味著Java程式的終止。

　　對於運行時異常、錯誤或可查異常，Java技術所要求的異常處理方式有所不同。

　　由於運行時異常的不可查性，為了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，允許應用程式忽略運行時異常。

　　對於方法運行中可能出現的Error，當運行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因為，大多數Error異常屬於永遠不能被允許發生的狀況，也屬於合理的應用程式不該捕捉的異常。

　　對於所有的可查異常，Java規定：一個方法必須捕捉，或宣告拋出方法之外。也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常。

　　能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由於自身語句所引發並拋出的異常，也可能是由某個調用的方法或Java運行時 系統等拋出的異常。也就是說，一個方法所能捕捉的異常，一定是Java程式碼在某處所拋出的異常。簡單地說，異常總是先被拋出，後被捕捉的。

　　任何Java程式碼都可以拋出異常，如：自己寫的程式碼、來自Java開發環境包中程式碼，或是Java執行時間系統。無論是誰，都可以透過Java的throw語句拋出異常。

　　從方法中拋出的任何異常都必須使用throws子句。

　　捕捉異常透過try-catch語句或try-catch-finally語句實現。

　　整體來說，Java規定：對於可查異常必須捕捉、或宣告拋出。允許忽略不可查的RuntimeException和Error。

　　3.1 捕获异常：try、catch 和 finally

　　1.try-catch语句

　　在Java中，异常通过try-catch语句捕获。其一般语法形式为：

try { 
    // 可能会发生异常的程序代码 
} catch (Type1 id1){ 
    // 捕获并处置try抛出的异常类型Type1 
} 
catch (Type2 id2){ 
     //捕获并处置try抛出的异常类型Type2 
}

关键词try后的一对大括号将一块可能发生异常的代码包起来，称为监控区域。Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之 外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。

　　匹配的原则是：如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。

　　例1 捕捉throw语句抛出的“除数为0”异常。

public class TestException { 
    public static void main(String[] args) { 
        int a = 6; 
        int b = 0; 
        try { // try监控区域 
               
            if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常 
            System.out.println("a/b的值是：" + a / b); 
        } 
        catch (ArithmeticException e) { // catch捕捉异常 
            System.out.println("程序出现异常，变量b不能为0。"); 
        } 
        System.out.println("程序正常结束。"); 
    } 
}

　　运行结果：

　　程序出现异常，变量b不能为0。

　　程序正常结束。

　　例1 在try监控区域通过if语句进行判断，当“除数为0”的错误条件成立时引发ArithmeticException异常，创建 ArithmeticException异常对象，并由throw语句将异常抛给Java运行时系统，由系统寻找匹配的异常处理器catch并运行相应异 常处理代码，打印输出“程序出现异常，变量b不能为0。”try-catch语句结束，继续程序流程。

　　事实上，“除数为0”等ArithmeticException，是RuntimException的子类。而运行时异常将由运行时系统自动抛出，不需要使用throw语句。

　　例2 捕捉运行时系统自动抛出“除数为0”引发的ArithmeticException异常。

public static void main(String[] args) { 
        int a = 6; 
        int b = 0; 
        try { 
            System.out.println("a/b的值是：" + a / b); 
        } catch (ArithmeticException e) { 
            System.out.println("程序出现异常，变量b不能为0。"); 
        } 
        System.out.println("程序正常结束。"); 
    } 
}

运行结果：

　　程序出现异常，变量b不能为0。

　　程序正常结束。

　　例2 中的语句：

　　System.out.println(“a/b的值是：” + a/b);

　　在运行中出现“除数为0”错误，引发ArithmeticException异常。运行时系统创建异常对象并抛出监控区域，转而匹配合适的异常处理器catch，并执行相应的异常处理代码。

　　由于检查运行时异常的代价远大于捕捉异常所带来的益处，运行时异常不可查。Java编译器允许忽略运行时异常，一个方法可以既不捕捉，也不声明抛出运行时异常。

　　例3 不捕捉、也不声明抛出运行时异常。

public class TestException { 
    public static void main(String[] args) { 
        int a, b; 
        a = 6; 
        b = 0; // 除数b 的值为0 
        System.out.println(a / b); 
    } 
}

运行结果：

　　Exception in thread “main” java.lang.ArithmeticException: / by zero
at Test.TestException.main(TestException.java:8)

　　例4 程序可能存在除数为0异常和数组下标越界异常。

public class TestException { 
    public static void main(String[] args) { 
        int[] intArray = new int[3]; 
        try { 
            for (int i = 0; i <= intArray.length; i++) { 
                intArray[i] = i; 
                System.out.println("intArray[" + i + "] = " + intArray[i]); 
                System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值:  " 
                        + intArray[i] % (i - 2)); 
            } 
        } catch (ArrayIndexOutOfBoundsException e) { 
            System.out.println("intArray数组下标越界异常。"); 
        } catch (ArithmeticException e) { 
            System.out.println("除数为0异常。"); 
        } 
        System.out.println("程序正常结束。"); 
    } 
}

运行结果：

　　intArray[0] = 0

　　intArray[0]模 -2的值: 0

　　intArray[1] = 1

　　intArray[1]模 -1的值: 0

　　intArray[2] = 2

　　除数为0异常。

　　程序正常结束。

　　例4 程序可能会出现除数为0异常，还可能会出现数组下标越界异常。程序运行过程中ArithmeticException异常类型是先行匹配的，因此执行相匹配的catch语句：

catch (ArithmeticException e){ 
      System.out.println("除数为0异常。"); 
 }

需要注意的是，一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

　　Java通过异常类描述异常类型，异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子 句放在前面，同时尽量将捕获相对高层的异常类的catch子句放在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽。

　　RuntimeException异常类包括运行时各种常见的异常，ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此，RuntimeException异常类的catch子句应该放在 最后面，否则可能会屏蔽其后的特定异常处理或引起编译错误。

　　2. try－catch-finally语句

　　try-catch语句还可以包括第三部分，就是finally子句。它表示无论是否出现异常，都应当执行的内容。try-catch-finally语句的一般语法形式为：

try { 
    // 可能会发生异常的程序代码 
} catch (Type1 id1) { 
    // 捕获并处理try抛出的异常类型Type1 
} catch (Type2 id2) { 
    // 捕获并处理try抛出的异常类型Type2 
} finally { 
    // 无论是否发生异常，都将执行的语句块 
}

例5 带finally子句的异常处理程序。

public class TestException { 
    public static void main(String args[]) { 
        int i = 0; 
        String greetings[] = { " Hello world !", " Hello World !! ", 
                " HELLO WORLD !!!" }; 
        while (i < 4) { 
            try { 
                // 特别注意循环控制变量i的设计，避免造成无限循环 
                System.out.println(greetings[i++]); 
            } catch (ArrayIndexOutOfBoundsException e) { 
                System.out.println("数组下标越界异常"); 
            } finally { 
                System.out.println("--------------------------"); 
            } 
        } 
    } 
}

运行结果：

　　Hello world !

　　————————–

　　Hello World !!

　　————————–

　　HELLO WORLD !!!

　　————————–

　　数组下标越界异常

　　————————–

　　在例5中，请特别注意try子句中语句块的设计，如果设计为如下，将会出现死循环。如果设计为：

try { 
      System.out.println (greetings[i]); i++; 
}

小结：

　　try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
　　catch 块：用于处理try捕获到的异常。
　　finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
　　1）在finally语句块中发生了异常。
　　2）在前面的代码中用了System.exit()退出程序。
　　3）程序所在的线程死亡。
　　4）关闭CPU。

　　3. try-catch-finally 规则(异常处理语句的语法规则）：

　　1) 必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
　　2) 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
　　3) catch 块与相应的异常类的类型相关。
　　4) 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
　　5) 可嵌套 try-catch-finally 结构。
　　6) 在 try-catch-finally 结构中，可重新抛出异常。
　　7) 除了下列情况，总将执行 finally 做为结束：JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。

　　4. try、catch、finally语句块的执行顺序:

　　1)当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；

　　2)当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；

　　3)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；

　　图示try、catch、finally语句块的执行：

3.2 抛出异常

　　任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。

　　1. throws抛出异常

　　如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障，汽车本身没办法处理这个故障，那就让开车的人来处理。

　　throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为：

methodname throws Exception1,Exception2,..,ExceptionN 
{ 
}

方法名后的throws Exception1,Exception2,…,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理。例如：

import java.lang.Exception; 
public class TestException { 
    static void pop() throws NegativeArraySizeException { 
        // 定义方法并抛出NegativeArraySizeException异常 
        int[] arr = new int[-3]; // 创建数组 
    } 
   
    public static void main(String[] args) { // 主方法 
        try { // try语句处理异常信息 
            pop(); // 调用pop()方法 
        } catch (NegativeArraySizeException e) { 
            System.out.println("pop()方法抛出的异常");// 输出异常信息 
        } 
    } 
   
}

使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。

　　pop方法没有处理异常NegativeArraySizeException，而是由main函数来处理。

　　Throws抛出异常的规则：

　　1) 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

　　2）必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误

　　3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。

　　4）调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

　　例如：

void method1() throws IOException{}  //合法   
   
//编译错误，必须捕获或声明抛出IOException   
void method2(){   
  method1();   
}   
    
//合法，声明抛出IOException   
void method3()throws IOException {   
  method1();   
}   
    
//合法，声明抛出Exception，IOException是Exception的子类   
void method4()throws Exception {   
  method1();   
}   
    
//合法，捕获IOException   
void method5(){   
 try{   
    method1();   
 }catch(IOException e){…}   
}   
    
//编译错误，必须捕获或声明抛出Exception   
void method6(){   
  try{   
    method1();   
  }catch(IOException e){throw new Exception();}   
}   
    
//合法，声明抛出Exception   
void method7()throws Exception{   
 try{   
  method1();   
 }catch(IOException e){throw new Exception();}   
}

判断一个方法可能会出现异常的依据如下：

　　1）方法中有throw语句。例如，以上method7()方法的catch代码块有throw语句。

　　2）调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，method3()方法调用了method1()方法，method1()方法声明抛出IOException，因此，在method3()方法中可能会出现IOException。

　　2. 使用throw抛出异常

　　throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

　　我们知道，异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为：

　　throw new exceptionname;

　　例如抛出一个IOException类的异常对象：

　　throw new IOException;

　　要注意的是，throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的：

　　throw new String(“exception”);

　　这是因为String 不是Throwable 类的子类。

　　如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

　　如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。

package Test; 
import java.lang.Exception; 
public class TestException { 
    static int quotient(int x, int y) throws MyException { // 定义方法抛出异常 
        if (y < 0) { // 判断参数是否小于0 
            throw new MyException("除数不能是负数"); // 异常信息 
        } 
        return x/y; // 返回值 
    } 
    public static void main(String args[]) { // 主方法 
        int  a =3; 
        int  b =0;  
        try { // try语句包含可能发生异常的语句 
            int result = quotient(a, b); // 调用方法quotient() 
        } catch (MyException e) { // 处理自定义异常 
            System.out.println(e.getMessage()); // 输出异常信息 
        } catch (ArithmeticException e) { // 处理ArithmeticException异常 
            System.out.println("除数不能为0"); // 输出提示信息 
        } catch (Exception e) { // 处理其他异常 
            System.out.println("程序发生了其他的异常"); // 输出提示信息 
        } 
    } 
   
} 
class MyException extends Exception { // 创建自定义异常类 
    String message; // 定义String类型变量 
    public MyException(String ErrorMessagr) { // 父类方法 
        message = ErrorMessagr; 
    } 
   
    public String getMessage() { // 覆盖getMessage()方法 
        return message; 
    } 
}

3.3 异常链

　　1) 如果调用quotient(3,-1)，将发生MyException异常，程序调转到catch (MyException e)代码块中执行；

　　2) 如果调用quotient(5,0)，将会因“除数为0”错误引发ArithmeticException异常，属于运行时异常类，由Java运行时系统自动抛出。quotient（）方法没有捕捉ArithmeticException异常，Java运行时系统将沿方法调用栈查到main方法，将抛出的异常上传至quotient（）方法的调用者：

　　int result = quotient(a, b); // 调用方法quotient()

　　由于该语句在try监控区域内，因此传回的“除数为0”的ArithmeticException异常由Java运行时系统抛出，并匹配catch子句：

catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println(“除数不能为0″); // 输出提示信息
}

    处理结果是输出“除数不能为0”。Java这种向上传递异常信息的处理机制，形成异常链。

　　Java方法抛出的可查异常将依据调用栈、沿着方法调用的层次结构一直传递到具备处理能力的调用方法，最高层次到main方法为止。如果异常传递到main方法，而main不具备处理能力，也没有通过throws声明抛出该异常，将可能出现编译错误。

　　3)如还有其他异常发生，将使用catch (Exception e)捕捉异常。由于Exception是所有异常类的父类，如果将catch (Exception e)代码块放在其他两个代码块的前面，后面的代码块将永远得不到执行，就没有什么意义了，所以catch语句的顺序不可掉换。

　　3.4 Throwable类中的常用方法

　　注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句”e.getMessage();”用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

　　getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。

　　getMeage()：返回异常的消息信息。

　　printStackTrace()：物件的堆疊追蹤輸出至錯誤輸出流，作為欄位 System.err 的值。

　　有時為了簡單會忽略掉catch語句後的程式碼，這樣try-catch語句就成了一種擺設，一旦程式在運作過程中出現了異常，就會忽略處理異常，而錯誤發生的原因很難找到。

　　在Java中提供了一些異常用來描述經常發生的錯誤，對於這些異常，有的需要程式設計師進行捕獲處理或聲明拋出，有的是由Java虛擬機自動進行捕獲處理。 Java中常見的異常類別:

　　1. runtimeException子類別:

    1、 java.lang.ArrayIndexOutOfBoundsException

    陣列索引越界異常。當數組的索引值為負數或大於等於數組大小時拋出。

    2、java.lang.ArithmeticException

    算術條件異常。譬如：整數除零等。

    3、java.lang.NullPointerException

    空白指標異常。當應用程式試圖在要求使用物件的地方使用了null時，拋出該異常。譬如：呼叫null物件的實例方法、存取null物件的屬性、計算null物件的長度、使用throw語句拋出null等等

    4、java.lang.ClassNotFoundException

    找不到類別異常。當應用程式試圖根據字串形式的類別名稱構造類，而在遍歷CLASSPAH之後找不到對應名稱的class檔案時，拋出該異常。

   5、java.lang.NegativeArraySizeException  數組長度為負異常

   6、java.lang.ArrayStoreException 數組中包含不兼容的值拋出的異常

   7、java.lang.SecurityException 安全性異常

   8、 java.lang.IllegalArgumentException 非法參數異常

　　2.IOException

IOException：操作輸入流和輸出流時可能出現的例外。

EOFException   檔案已結束異常

FileNotFoundException   檔案未找到異常

　　3. 其他

ClassCastException SQLp Exception   操作資料庫異常類別

NoSuchFieldException欄位找不到例外

NoSuchMethodException   方法找不到被拋出的例外

NumberFormatException    字串轉換為數字拋出的例外情況

StringIndexOutOfBoundsException 無法存取某一類antiationException當應用程式試圖使用Class類別中的newInstance()方法建立一個類別的實例，而指定的類別物件無法被實例化時，拋出該異常

　　5.自訂異常

　　使用Java內建的異常類別可以描述在編程時出現的大部分異常情況。除此之外，用戶還可以自訂異常。使用者自訂異常類，只需繼承Exception類別即可。

　　在程式中使用自訂異常類，大體可分為以下幾個步驟。

　　（1）建立自訂異常類別。

　　（2）在方法中透過throw關鍵字拋出異常物件。

　　（3）如果在當前拋出異常的方法中處理異常，可以使用try-catch語句捕獲並處理；否則在方法的聲明處通過throws關鍵字指明要拋出給方法調用者的異常，繼續進行下一步操作。

　　（4）在出現異常方法的呼叫者中捕獲並處理異常。

　　在上面的「使用throw拋出異常」範例已經提到了。