摘要：例如將型對象轉換為類拋出的異常表明向方法傳遞了一個不合法或不正確的參數。應用程序可以將此類子類化以指示類似的異常。用非法索引訪問數組時拋出的異常。

沒有完美的程序，所以我們需要不斷地完善，考慮各種可能性，我們要將除了自己以外的任何用戶或者操作者都當成傻子來考慮問題
在我們開發過程中 我們運行時常常會遇到 這樣java.lang.XxxException的信息，這代表程序發生了一些錯誤，也叫作異常

異常情形是指阻止當前方法或者作用域繼續執行的問題    ——《Think in Java》

簡單概括：程序出現不正常情況后，程序將會跳出當前環境，并且拋出異常。

(1) Error —— 錯誤：程序無法處理的嚴重錯誤，我們不作處理

這種錯誤一般來說與操作者無關，并且開發者與應用程序沒有能力去解決這一問題，通常情況下，JVM會做出終止線程的動作

(2) Exception —— 異常：異常可以分為運行時異常和編譯期異常

RuntimeException：即運行時異常，我們必須修正代碼

這些異常通常是由于一些邏輯錯誤產生的

這類異常在代碼編寫的時候不會被編譯器所檢測出來，是可以不需要被捕獲，但是程序員 也可以根據需要行捕獲拋出，（不受檢查異常）這類異常通常是可以被程序員避免的。
常見的RUNtimeException有：NullpointException（空指針異常），ClassCastException （類型轉 換異常），IndexOutOfBoundsException（數組越界異常）等。

非RuntimeException：編譯期異常，必須處理，否則程序編譯無法通過

這類異常在編譯時編譯器會提示需要捕獲，如果不進行捕獲則編譯錯誤。

常見編譯異常有：IOException（流傳輸異常），SQLException（數據庫操作異常）等。

A：Java 的非檢查性異常

B：Java的檢查性異常

A：捕獲單個異常

try{
    //程序代碼
}catch (ExceptionName e1){
    //Catch塊
}

B：多重捕獲塊

try{
    //程序代碼
}catch (異常類型1 異常的變量名1){
    ......
}catch (異常類型2 異常的變量名2){
    ......
}catch (異常類型3 異常的變量名3){
    ......
}

try：用于監聽異常

catch：用于捕獲處理異常

try 后面的一對大括號內的內容即受到監控的程序，也就是說這一段代碼是可能存在異常的，而Catch中由開發者，根據自身推斷可能存在的異常，書寫對應異常類型以及處理方式，當程序發生異常時，會創建異常對象，并且將異常拋出到此環境外，Java運行時系統會尋找與發生異常所匹配的catch子句，當找到一個對應語句后則不再尋找其他catch塊

public class Demo {
    public static void main(String[] args) {
        int a = 520;
        int b = 0;
        int c;

        try {
            System.out.println("這是一個被除數為0的式子");
            c = a / b;
        } catch (ArithmeticException e) {
            System.out.println("除數不能為0");
        }
    }
}

//運行結果
這是一個被除數為0的式子
除數不能為0

通過上例可以看到，被監控的語句中先依次正常執行，當遇到存在問題的語句時，找到匹配異常，并且執行catch塊中的語句

而一般來說我們會在catch語句塊中通過異常對象執行異常方法

我們還是用上面的例子給出異常方法的測試

System.out.println(e.getMessage());

/ by zero

System.out.println(e.getCause());

null

System.out.println(e.toString());

java.lang.ArithmeticException: / by zero

e.printStackTrace();

java.lang.ArithmeticException: / by zero
    at cn.bwh_01_Throwable.Demo.main(Demo.java:10)

我們在 try-catch的基礎上再補充一個finally的知識

finally 關鍵字用來創建在 try 代碼塊后面執行的代碼塊無論是否發生異常，finally 代碼塊中的代碼總會被執行，在 finally 代碼塊中，可以運行清理類型等收尾善后性質的語句，finally 代碼塊出現在 catch 代碼塊最后，語法如下：

try{
    ......
}catch(異常類型1 異常的變量名1){
    ......
}catch(異常類型2 異常的變量名2){
    ......
}finally{
    ......
}

無論是否發生異常，fianlly始終都是會運行的

這里就不得不提一個非常重要的注意點，那就是當return遇到finally！

A：return遇到finally

我們來看下面一個例程：

public class Demo2 {
    public static void main(String[] args) {
        System.out.println(test());
    }

    public static String test(){
        int[] array = new int[2];
        try{
            array[3] = 0;
            return "This is try";
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
            return "This is catch 1";
        }catch (Exception e){
            System.out.println(e);
            return "This is catch 2";
        }finally {
            System.out.println("This is finally");
            //return "This is finally"s return";
        }
    }
}

//運行結果
java.lang.ArrayIndexOutOfBoundsException: 3
This is finally
This is catch 1

由此我們得出一個結論：在catch中遇到return時，仍然會先執行finally語句，再回來執行對應catch語句中的return語句

但是我們如果將finally中return行中的注釋去掉，運行結果就會變成下面這樣子

//運行結果
java.lang.ArrayIndexOutOfBoundsException: 3
This is finally
This is finally"s return

結果就是返回值會被finally中的return語句重新覆蓋

B：catch 順序問題

public class Demo3 {
    public static void main(String[] args) {
        int[] array = new int[2];
        try{
            array[5] = 0;
        }catch (Exception e){

        }catch (ArrayIndexOutOfBoundsException e){

        }
    }
}

//運行結果
Error:(8, 10) java: 已捕獲到異常錯誤java.lang.ArrayIndexOutOfBoundsException

對于多個catch的情況，當try中程序發生異常，會按照從上往下的順序與catch進行匹配，一旦與其中一個匹配后就不會再與后面的catch進行匹配了，所以，在書寫catch語句的時候，一定要把范圍小的放在前面，范圍大的放在后面！

將自己處理不了的，在方法或者語句上聲明，告訴調用者，這里有問題

如果一個方法沒有捕獲到檢查性異常，那么該方法就必須使用throws關鍵字聲明（聲明拋出多個異常，之間使用逗號隔開），也可以在語句中使用throw關鍵字拋出一個異常。

//演示throw
public class Demo4 {
    public static void main(String[] args) {
        test();
    }

    public static void test() {
        int a = 520;
        int b = 0;
        if (b == 0) {
            throw new ArithmeticException();
        } else {
            System.out.println(a / b);
        }
    }
}

//運行結果
Exception in thread "main" java.lang.ArithmeticException

//演示throws

public class Demo4 {
    public static void main(String[] args) {
        try {
            test();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void test() throws Exception {
        int a = 520;
        int b = 0;
        if (b == 0) {
            throw new Exception();
        } else {
            System.out.println(a / b);
        }
    }
}

//運行結果
java.lang.Exception

throws和throw的區別

A：throws

用在方法聲明后，跟的是異常類名

可以跟多個異常類名，用逗號隔開

表示拋出異常，由該方法的調用者來處理

throws表示出現異常的一種可能性，不一定會發生這些異常

B：throw

用在方法體內，跟的是異常對象名

只能拋出一個異常對象名

表示拋出異常，由方法體內的語句處理

執行throw則一定拋出了某種異常

Java內置的異常類，基本可以滿足我們在編程中遇到的大部分異常情況，此外我們還可以自定義異常類，只需要繼承Exception類即可

基本步驟：

創建自定義異常類

在方法中通過throw拋出異常對象

在當前拋出異常的方法中處理異常，可以使用try-catch語句捕獲處理

也可以在方法聲明處使用throws將異常拋給方法調用者

在出現異常方法的調用者中捕獲并且處理異常

class MyException extends Exception {  // 自定義的類
    MyException(String s) {
        super(s);
    }
}
class Demo {
    void method() throws MyException {
        throw new MyException("Wrong"); // 拋出自定義的類
    }
}
class DemoTest {
    public static void main(String[] args){
        try {
            new Demo().method();
        }
        catch(MyException e) {
            System.out.println(e.getMessage());
        }
    } 
}

//運行結果
Wrong

異常就是在程序發生異常時，強制終止程序運行，并且將異常信息返回，由開發者決定是否處理異常

簡單說一下這個異常機制的過程：

當程序無法運行后，它會從當前環境中跳出，并且拋出異常，之后，它會先new一個異常對象，然后在異常位置終止程序，并且將異常對象的引用從當前環境中返回，這時候異常處理機制接管程序，并且開始尋找可以繼續執行程序的恰當位置。

如果內容中有什么不足，或者錯誤的地方，歡迎大家給我留言提出意見, 蟹蟹大家 ！^_^

如果能幫到你的話，那就來關注我吧！（系列文章均會在公眾號第一時間更新）

在這里的我們素不相識，卻都在為了自己的夢而努力 ?
一個堅持推送原創Java技術的公眾號：理想二旬不止