JAVA SE 基礎複習-面向對象 異常機制

轉載自：Java的異常解析

1. 引子

       try…catch…finally恐怕是你們再熟悉不過的語句了，並且感受用起來也是很簡單，邏輯上彷佛也是很容易理解。不過，我親自體驗的「教訓」告訴我，這個東西可不是想象中的那麼簡單、聽話。不信？那你看看下面的代碼，「猜猜」它執行後的結果會是什麼？不要日後看答案、也不準執行代碼看真正答案哦。若是你的答案是正確，那麼這篇文章你就不用浪費時間看啦。

 

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=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false

若是你的答案真的如上面所說，那麼你錯啦。^_^，那就建議你仔細看一看這篇文章或者拿上面的代碼按各類不一樣的狀況修改、執行、測試，你會發現有不少事情不是原來想象中的那麼簡單的。如今公佈正確答案：

i=2

i=1

testEx2, catch exception

testEx2, finally; return value=false

testEx1, finally; return value=false

testEx, finally; return value=false

 

注意說明：

 

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

 

 

finally若是有return會覆蓋catch裏的throw，一樣若是finally裏有throw會覆蓋catch裏的return。

進而若是catch裏和finally都有return finally中的return會覆蓋catch中的。throw也是如此。

 2.JAVA異常

   異常指不期而至的各類情況，如：文件找不到、網絡鏈接失敗、非法參數等。異常是一個事件，它發生在程序運行期間，干擾了正常的指令流程。Java通 過API中Throwable類的衆多子類描述各類不一樣的異常。於是，Java異常都是對象，是Throwable子類的實例，描述了出如今一段編碼中的 錯誤條件。當條件生成時，錯誤將引起異常。

      Java異常類層次結構圖：

        

 

                                                                    圖1 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異常，通常狀況下不自定義檢查異常。

 

    

 

 

 4.處理異常機制

        在 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。

4.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語句塊的執行：

                                          圖2  圖示try、catch、finally語句塊的執行

4.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;
    }
}

 

4.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語句的順序不可掉換。

4.4 Throwable類中的經常使用方法

注意：catch關鍵字後面括號中的Exception類型的參數e。Exception就是try代碼塊傳遞給catch代碼塊的變量類型，e就是變量名。catch代碼塊中語句"e.getMessage();"用於輸出錯誤性質。一般異常處理經常使用3個函數來獲取異常的有關信息:

     getCause()：返回拋出異常的緣由。若是 cause 不存在或未知，則返回 null。

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

　 printStackTrace()：對象的堆棧跟蹤輸出至錯誤輸出流，做爲字段 System.err 的值。

     有時爲了簡單會忽略掉catch語句後的代碼，這樣try-catch語句就成了一種擺設，一旦程序在運行過程當中出現了異常，就會忽略處理異常，而錯誤發生的緣由很難查找。

 

 

 

 5.Java常見異常

  

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

 

1. runtimeException子類:

    一、 java.lang.ArrayIndexOutOfBoundsException     數組索引越界異常。當對數組的索引值爲負數或大於等於數組大小時拋出。     二、java.lang.ArithmeticException     算術條件異常。譬如：整數除零等。     三、java.lang.NullPointerException     空指針異常。當應用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調用null對象的實例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等     四、java.lang.ClassNotFoundException     找不到類異常。當應用試圖根據字符串形式的類名構造類，而在遍歷CLASSPAH以後找不到對應名稱的class文件時，拋出該異常。

   五、java.lang.NegativeArraySizeException  數組長度爲負異常

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

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

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

2.IOException

IOException：操做輸入流和輸出流時可能出現的異常。

EOFException   文件已結束異常

FileNotFoundException   文件未找到異常

3. 其餘

ClassCastException    類型轉換異常類

ArrayStoreException  數組中包含不兼容的值拋出的異常

SQLException   操做數據庫異常類

NoSuchFieldException   字段未找到異常

NoSuchMethodException   方法未找到拋出的異常

NumberFormatException    字符串轉換爲數字拋出的異常

StringIndexOutOfBoundsException 字符串索引超出範圍拋出的異常

IllegalAccessException  不容許訪問某類異常

InstantiationException  當應用程序試圖使用Class類中的newInstance()方法建立一個類的實例，而指定的類對象沒法被實例化時，拋出該異常

 

 

    

 

 

 6.自定義異常

 

使用Java內置的異常類能夠描述在編程時出現的大部分異常狀況。除此以外，用戶還能夠自定義異常。用戶自定義異常類，只需繼承Exception類便可。     在程序中使用自定義異常類，大致可分爲如下幾個步驟。 （1）建立自定義異常類。 （2）在方法中經過throw關鍵字拋出異常對象。 （3）若是在當前拋出異常的方法中處理異常，可使用try-catch語句捕獲並處理；不然在方法的聲明處經過throws關鍵字指明要拋出給方法調用者的異常，繼續進行下一步操做。 （4）在出現異常方法的調用者中捕獲並處理異常。

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