一、前言

這篇技術博客是我復習尚硅谷JavaSE教程做的筆記總結，方便大家的學習同時也方便自己，博客內容非復制粘貼，純手寫，如果對你有幫助，歡迎點贊評論收藏！

二、例外概述及例外體系結構

1.概述：

我們在做程式開發時候，都想著把代碼寫的完美無瑕（不大可能），但是真實情況是在系統運行代碼時，仍然會遇到一些問題，不能靠代碼避免，比如：

• 客戶輸入的資料格式
• 讀取檔案是否存在
• 網路是否始終保持通暢

我們把這類問題，歸結為例外！

例外概念：在Java語言中，將程式執行中發生的不正常情況稱為例外（例外指的并不是語法錯誤，語法錯了，編譯不通過，不會產生位元組碼檔案，根本不能運行）

Java中例外分為兩類：

1. Error：java虛擬機無法解決的嚴重問題（JVM系統內部錯誤、資源耗盡），一般沒辦法撰寫針對性代碼進行處理（處理不了）

public class ErrorTest {
    public static void main(String[] args) {
        //1.堆疊溢位java.lang.StackOverflowError
        main(args);
        
        //2.堆溢位：java.lang.OutOfMemoryError
        Integer[] arr = new Integer[1024 * 1024 * 1024];
    }
}

2. Exception：因編程錯誤或偶爾的外在因素導致的一般性問題，可以使用針對性的代碼進行處理（空指標訪問，試圖讀取不存在的檔案，網路連接中斷，陣列角標越界等）

注意：我們平常將Error和Exception都稱作廣義上的例外，但是由于我們不處理Error，所以我們平時在開發中提到的例外一般指的是Exception，我們說的例外處理指的就是狹義上的例外：Exception，所以此博客主要講解的例外處理針對的是Exception

2.例外體系結構

捕獲錯誤最理想的是編譯期間，但有的錯誤只在運行期間發生，比如：除數為0、陣列下標越界等

Exception分類：編譯時例外（需要處理）、運行時例外（一般不處理）

體系結構圖如下：
例外的頂級父類是 java.lang.Throwable，其下有兩個子類：java.lang.Error 與 java.lang.Exception，平常所說的例外指java.lang.Exception ，

三、例外處理方式（兩種）

Java采用的例外處理機制，是將例外處理的程式代碼集中在一起，與正常的程式代碼分開，使得程式簡潔、優雅，并易于維護，其實體外處理并非真正意義上將例外代碼改正，修改代碼操作還是需要開發人員自己去做！

例外的處理：抓拋模型
程序一（拋）：程式在正常執行程序中，一旦出現例外，就會在例外代碼出生成一個對應例外類的物件，并將此物件拋出，一旦拋出物件以后，其后的代碼就不再執行，
程序二（抓）：可以理解為例外處理的方式：①try-catch-finally ②throws

關于例外物件的產生：

• 系統自動生成的例外物件
• 手動生成一個例外物件，并拋出（throw）

1.方式一：try-catch-finally

使用格式：

	try{
	...... //可能產生例外的代碼
	}
	catch(ExceptionName1 e){
	...... //當產生ExceptionName1型例外時的處置措施
	}
	catch(ExceptionName2 e){
	...... //當產生ExceptionName2型例外時的處置措施
	}
	......
	finally{
	...... //無論是否發生例外，都無條件執行的陳述句
	}
	
	注意：finally為可選結構，是否使用取決于自己

代碼展示與說明：

/**
 * 說明：
 * 1.finally是可選的
 * 2.使用try將可能出現例外的代碼包裝起來，在執行程序中，一旦出現例外，就會生成一個對應例外類的物件
 *   根據此物件的型別，去catch中進行匹配
 * 3.一旦try中的例外物件匹配到某一個catch時，就進入catch中進行例外的處理，一旦處理完成就跳出
 *   當前的try-catch結構（在沒寫finally情況下），繼續執行其后的代碼
 * 4.catch中的例外型別如果沒有子父類關系，則先宣告誰都無所謂
 *   catch中的例外型別如果滿足子父類關系，則要求子類一定宣告在父類的上面，否則報錯
 * 5.常用的例外物件處理的方式：①String getMessage() ②printStackTrace()
 * 6.在try中宣告的變數，在出了try結構后，不能再被呼叫
 */
public class ExceptionTest {
    public static void main(String[] args) {
        String str = "123";
        str = "abc";
        int num = 0;
        try {
            num = Integer.parseInt(str); //可能出現例外的代碼
            System.out.println("hello------1");
        }catch (NullPointerException e){
            System.out.println("出現空指標例外了，不要急");

        }catch (NumberFormatException e){
            //System.out.println("出現數值轉換例外了，不要急");
            //System.out.println(e.getMessage());
            e.printStackTrace();
        }catch (Exception e){
            System.out.println("出現例外了，不要急");
        }
        System.out.println(num);
        System.out.println("hello------2");
    }
}

上述代碼中只使用了try-catch結構，并沒有使用finally，接下來我們學習一下finally的使用細節：

1. finally中宣告的是一定會被執行的代碼，即使catch中有出現例外，
   try中有return陳述句，catch中有return陳述句等情況
2. 像資料庫連接、輸入輸出流、網路編程Socket等資源，JVM是不能自動回收的，
   我們需要自己手動進行資源釋放，此時資源釋放需要宣告在finally中，
   為了防止釋放之前的代碼有例外，導致資源不被釋放， 所以放在finally中
3. try-catch-finally可以嵌套使用

//不論是catch中有例外，還是catch中有return，我們的finally代碼塊一定會執行！
public class FinallyTest {
    public static void main(String[] args) {
        try {
            int a = 10;
            int b = 0;
            System.out.println(a / b);
        }catch (ArithmeticException e){
            //e.printStackTrace();
            int[] arr = new int[10];
            System.out.println(arr[10]); //回報空指標例外，但是沒有處理
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("就算你報例外，我也一定要執行！");
        }
    }
}

我們在開發程序中對于運行時例外不用try-catch處理，比如說空指標例外，出現這類例外使用try-catch
也無法真正意義上解決，我們得去改代碼，所以———運行時例外，不用try-catch

但是對于編譯時例外需要對它try-catch，否則連編譯期都過不去，更別說運行了！
編譯過去了，如果運行正確就ok，如果運行出錯，就是將例外延遲到運行期出現！
相當于我們使用try-catch結構將編譯時例外變成運行時例外！

體會1：使用try-catch-finally處理編譯時例外，使得程式在編譯就不在報錯但是運行時仍可能報錯，相當于我們使用try-catch-finally將一個編譯時可能出現的例外延遲到運行時出現，

體會2：開發中，由于運行時例外比較常見，所以我們通常就不針對運行時例外撰寫try-catch-finally，針對于編譯時例外一定要考慮例外的處理（進行代碼修改）！

2.方式二：throws

該方式寫在方法的宣告處，指明此方法執行時可能會拋出的例外型別，一旦當方法體執行時出現例外，仍會在例外代碼處生成一個例外類的物件，此物件滿足throws后例外型別時就會被拋出，例外代碼后續的代碼不再執行！

代碼演示：

public class ExceptionTest2{
    public static void main(String[] args){
        //如果拋給main方法，就需要try-catch處理了！
        //不能再向上拋出了
        try {
            method2();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void method2() throws IOException{
        method1();
    }

    public static void method1() throws IOException {
        File file = new File("hello.txt"); //檔案找不到，會報例外
        FileInputStream fis = new FileInputStream(file);

        int data = fis.read();//例外
        while (data != -1){
            System.out.println((char)data);
            data = fis.read(); //例外
        }
        fis.close();//例外
    }
}

體會：兩種例外處理方式的區別？

• try-catch-finally真正的將例外處理（并不是修改代碼修正例外）
• throws方式（甩鍋）只是將例外拋給方法的呼叫者，并沒有真正將例外處理掉！

注意：子類重寫的方法拋出的例外型別不大于（<=）父類被重寫方法拋出的例外型別

四、如何選擇處理例外方式

我們在開發中處理例外以該選擇這兩種方式中的哪一種呢？

• 如果父類中被重寫的方法沒有throws方式處理例外，則子類重寫的方法也不能夠使用throws（原因看上述注意），意味著子類重寫的方法中有例外，就必須使用try-catch-finally方式處理！
• 執行的方法a中，先后又呼叫了另外的幾個方法，這幾個方法是遞進關系執行的，建議這幾個方法使用throws方式進行處理，而執行的方法a可以考慮使用try-catch-finally方式進行處理

二次理解：我們現在的兩種例外處理方式，指的是代碼執行之前可能會出現問題，我們提前做一個預案，萬一出現問題了我們該怎么辦！比如：彈出一個提示框，當然我們同時要明白：例外處理并不是真正意義上講例外解決！例外處理機制不會幫助我們修正代碼，還是需要我們自己處理修改例外代碼！

五、手動拋出例外(throw)

關于例外物件的產生：

1. 系統自動生成的例外物件
2. 手動生成例外物件并拋出（throw）

代碼展示：

public class StudentTest {
    public static void main(String[] args) {
        try {
            Student s = new Student();
            //資料非法，需要處理例外物件
            //呼叫此方法進入到catch代碼塊中
            s.regist(-1001);
        } catch (Exception e) {
        	//控制臺輸出：您輸入的資料非法
            System.out.println(e.getMessage());
        }
    }
}

class Student{
    private int id;
	
    public void regist(int id) throws Exception {
        if (id > 0){
            this.id = id;
        }else {
            //手動拋出例外物件
            throw new Exception("您輸入的資料非法！");
        }
    }
}

六、自定義例外類

我們上述見到的例外都是Java提供好的（官方的），我們當然也可以自己去自定義例外：

如何自定義例外類？

• 1.自定義類繼承于現有的例外類結構：RuntimeException、Exception
• 2.提供全域常量：serialVersionUID 序列版本號，用于標識類
• 3.提供多載的構造器

代碼展示：

//自定義例外類
public class MyException extends RuntimeException{
    static final long serialVersionUID = -7034897190745766939L;

    public MyException() {

    }
    public MyException(String msg) {
        super(msg);
    }
}

//學生類
class Student{
    private int id;

    public void regist(int id){
        if (id > 0){
            this.id = id;
        }else {
            throw new MyException("不能輸入負數");
        }
    }
}

//測驗類
class Test{
    public static void main(String[] args) {
        try {
            Student s = new Student();
            s.regist(-1001);

        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

七、例外處理總結

5個關鍵字幾乎就能涵蓋例外處理的所有內容了！

面試題：throw和throws區別？

1. throw表示拋出一個例外物件，生成例外物件的程序，宣告在方法體內
2. throws屬于例外處理的一種方式，宣告在方法的宣告處