Java—例外

Java 是安全性很高的一門語言，故

什么是例外？

在程式的運行或者編譯時，所產生的錯誤統稱為例外 (也叫Bug)

例外的存在形式

例外在java中以類的形式存在，每一個例外類都可以創建例外物件
我們平時看到的例外，都被封裝成一個類
例如：0 為除數，例外為：ArithmeticException

查看在線檔案會發現：

Java例外體系

例外的分類

例外分為：運行時例外 和 編譯時例外

運行時例外

運行時例外又稱為：非受查例外，指的是在程式運行時所拋出的例外

特點：Java編譯器不會檢查它，也就是說，當程式中可能出現這類例外，即使沒有用try-catch陳述句捕獲它，也沒有用throws子句宣告拋出它，也會編譯通過

編譯時例外

編譯時例外又稱為：受查例外，在程式編譯時的例外
是RuntimeException以外的例外，型別上都屬于Exception類及其子類，從程式語法角度講是必須進行處理的例外，如果不處理，程式就不能編譯通過

錯誤 Error

是程式無法處理的錯誤，表示運行應用程式中較嚴重問題
錯誤是預測不到的，如果應用程式出現了Error，那么將無法恢復，只能重新啟動應用程式

編譯時例外和運行時例外的區別

常見的例外

我們之前已經接觸了一些例外，常見的例外還是有必要記住的

• 0為除數(算數例外)

int a = 10 / 0;

• 陣列下標越界(陣列下標越界例外)

int[] array = {1,2,3};
System.out.println(array[4]);

• 訪問 null(空指標例外)

空指標例外出現的概率非常高！！

int[] array = {1,2,3};
array = null;
System.out.println(array[2]);

防御式編程

程式出現問題的時候及時通知程式猿，主要有兩種主要的方式：

BYBL

Look Before You Leap，在操作之前就做充分的檢查
舉例：一個男孩子很喜歡一個女孩子，想要拉女孩子的手，提前問：我可以拉你的手嘛？

EAFP

It’s Easier to Ask Forgiveness than Permission，“事后獲取原諒比事前獲取許可更容易”，也就是先操作，遇到問題再處理
舉例：男孩子先拉的女孩子的手，女孩子很生氣，呼了一巴掌，男孩子再回來巴拉巴拉道歉

例外的核心就是EAFP

Java處理例外的語法

例外拋出—throws

指編程人員主動拋出一個例外
任何Java代碼都可以拋出例外，在方法宣告的位置上使用 throws 關鍵字拋出，拋給方法的呼叫者來處理，這種處理例外的態度：上報

舉例：

public static void testThrows() throws NullPointerException {
    Integer p = null;
    System.out.println(p + 1);
}

注意：

• 方法的呼叫者負責處理該例外
• 在定義方法時，把例外拋出就是為了提醒方法的使用者，有例外需要預處理
• 如果例外物件是 非RuntimeException，則需要在方法申明時加上該例外的拋出
  即需要加上 throws 陳述句 或者 在方法體內 try catch 處理該例外，否則編譯報錯
• 執行到 throw 陳述句，后面的陳述句塊不再執行

例外捕獲—try…catch

這個例外不會上報，自行處理，例外拋到此處為止，不再上拋

try {
 //可能出現例外的代碼
} 
catch (Exception1 e) { //引數：例外的型別 e
//捕獲try當中可能出現的例外
} 
catch (Exception2 e) { //引數：例外的型別 e
//捕獲try當中可能出現的例外
} finally {

}

舉例：

int[] array = {2,4,6,8};
try{
    System.out.println(array[4]);
}
catch (ArrayIndexOutOfBoundsException e){
    System.out.println("捕獲到陣列越界例外！");
}

對比：

注意：

• try{ } 包含了可能出現例外的代碼
• catch 可以有一個或多個，catch中是捕獲 try 當中可能出現的例外，可以通過 catch 捕獲多個例外
• catch 塊當中，一定要捕獲相應的例外，如果程式拋出的例外在 catch 塊當中不能被捕獲，則會交給JVM來處理例外，程式便會例外終止
• 當 try 中的代碼出現例外時，try 里例外之后的代碼不會執行，馬上會跳轉到相應的catch陳述句塊中，如果沒有例外便不會跳轉
• 不管是否出現例外，finally{ } 里的代碼都執行，finally和catch可以分開使用，但finally必須和try一塊使用
• 不建議直接捕獲 Exception 例外，要捕獲就捕獲具體的
• 不建議在 finally 中出現 return陳述句
• catch 只能處理對應種類的例外

try 負責回收資源

Scanner scan = new Scanner(System.in);
try{
    int n = scan.nextInt();
    System.out.println(10/n);
}
catch (ArithmeticException e){
    e.printStackTrace();
}
finally {
    scan.close();
}

在Idea里，會發現 try 背景色會加深，將滑鼠放在 try，按 Alt + Enter

出現上圖，回車即可！
然后代碼就會自動被優化：

即：將 Scan 物件在 try( )中創建，就能保證在 try 執行完畢后自動呼叫 Scanner 的 close 方法

向上傳遞，處理例外

先看代碼：

public static void func(){
    int[] array = {2,4,6,8};
    System.out.println(array[4]);
}

public static void main(String[] args) {
    func();
}

上述代碼，func 方法里存在陣列越界例外，但并沒有處理，到 main 中呼叫 func 方法，由于 main方法里也沒有處理該例外，則會交給 JVM，那么程式一運行，遇到例外，直接就會終止

改進：

public static void func(){
    int[] array = {2,4,6,8};
    System.out.println(array[4]);
}

public static void main(String[] args) {
    try {
        func();
    }
    catch (ArrayIndexOutOfBoundsException e){
        e.printStackTrace();
    }
    finally {
        System.out.println("hahaha");
    }

例外的傳遞是可以沿著堆疊向上傳遞的，方法是要在堆疊上開辟記憶體的

處理流程

1. 程式先執行 try 中的代碼
2. 若 try 中的代碼出現例外，就會結束 try 中的代碼，看和 catch 中的例外型別是否匹配
3. 若找到匹配的例外型別，就會執行 catch 中的代碼
4. 若沒有找到匹配的例外型別，就會將例外向上傳遞到上層呼叫者
5. 無論是否找到匹配的例外型別，finally 中的代碼都會被執行到(在該方法結束之前執行)
6. 若上層呼叫者也沒有處理的了例外，就繼續向上傳遞
7. 一直到 main 方法也沒有合適的代碼處理例外，就會交給 JVM 來進行處理，此時程式就會例外終止

自定義例外類

自定義例外類步驟：

1. 撰寫一個類繼承 Exception 或者 RuntimeException
2. 提供兩個 構造方法，一個無引數的，一個帶有 String 引數的

class MyException extends RuntimeException{
    //構造方法
    public MyException() {
        super();
    }
    public MyException(String message) {
        super(message);
    }
}

自己玩~~

public static void func(int x){
    if(x == 10){
        throw new MyException("x==10");
    }
}
public static void main(String[] args) {
    try {
        func(10);
    }
    catch (MyException e){
        e.printStackTrace();
    }
}

輸出結果：

注意事項：

• 一定要繼承一個父類例外，通常是 Exception / RuntimeException
• 一般建議繼承Exception，好處是必須要處理例外