Java例外處理詳解(全文干貨，寫得非常全，值得收藏)-有解無憂

一.初始Java例外

對例外的理解：例外:在Java語言中，將程式執行中發生的不正常情況稱為“例外”，(開發程序中的語法錯誤和邏輯錯誤不是例外)
Java程式在執行程序中所發生對例外事件可分為兩類：

Error:Java虛擬機無法解決的嚴重問題，如:JVM系統內部錯誤、資源耗盡等嚴重情況，比如:StackOverflowError和OOM，一般不撰寫針對性的代碼進行處理，
Exception: 其它因編程錯誤或偶然的外在因素導致的一般性問題，可以使用針對性的代碼進行處理，例如:
- 空指標訪問
- 試圖讀取不存在的檔案
- 網路連接中斷
- 陣列角標越界

運行時例外和編譯時例外

運行時例外
- 是指編譯器不要求強制處置的例外，一般是指編程時的邏輯錯誤，是程式員應該積極避免其出現的例外，java.lang.RuntimeException類及它的子類都是運行時例外，
- 對于這類例外，可以不作處理，因為這類例外很普遍，若全處理可能會對程式的可讀性和運行效率產生影響，
編譯時例外
- 是指編譯器要求必須處置的例外，即程式在運行時由于外界因素造成的一般性例外，編譯器要求Java程式必須捕獲或宣告所有編譯時例外，
- 對于這類例外，如果程式不處理，可能會帶來意想不到的結果，

在這里插入圖片描述

二.Error和Exception

1.Error

代碼示例一：java.lang.OutOfMemoryError（堆溢位）

public class ErrorTest {
    public static void main(String[] args) {
        //堆溢位:java.lang.OutOfMemoryError
        Long[] arr = new Long[1024*1024*1024];
    }
}

運行結果：
在這里插入圖片描述

代碼示例二：java.lang.StackOverflowError（堆疊溢位）

public class ErrorTest {
    public static void main(String[] args) {

        //堆疊溢位：java.lang.StackOverflowError
        main(args);
    }
}

運行結果：
在這里插入圖片描述

2.Exception（運行時例外和編譯時例外）

運行時例外

    /* ******************以下是運行時例外****************** */
    //ArithmeticException
    @Test
    public void test1(){
        int num1 = 3;
        int num2 = 0;
        int num3 = 3 / 0;
    }

    //InputMismatchException
    @Test
    public void test2(){
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        System.out.println(i);
        scanner.close();
    }

    //NumberFormatException
    @Test
    public void test3(){
        String str = "abcd";
        int num = Integer.parseInt(str);
    }

    //ClassCastException
    @Test
    public void test4(){
        Object obj = new Boolean(true);
        String str = (String)obj;
    }

    //IndexOutOfBoundsException
    @Test
    public void test5(){
        ArrayIndexOutOfBoundsException
        Byte[] bytes = new Byte[3];
        System.out.println(bytes[4]);
    }

    //NullPointerException
    @Test
    public void test6(){
        int[] arr = null;
        System.out.println(arr[1]);
    }

編譯時例外

/* ******************以下是編譯時例外****************** */
    @Test
    public void test7(){
        File file = new File("a.txt");
        //java.io.FileNotFoundException
        FileInputStream fis = new FileInputStream(file);
        //java.io.IOException
        int date = fis.read();
        while (date != -1){
            System.out.println((char)date);
            date = fis.read();
        }

        fis.close();
    }

ps:對于編譯時例外，我們需要例外處理

三.例外處理：抓拋模型

1.抓拋解釋

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

2.try-catch-finally的使用

try{
//可能出現例外的代碼

}catch(例外型別1 變數名1){
//處理例外的方式1
}catch(例外型別2 變數名2){
//處理例外的方式2
}catch(例外型別3 變數名3){
//處理例外的方式3
}
…
finally{
//一定會執行的代碼
}

說明：

finally是可選的，
使用try將可能會出現例外的代碼段包裝起來，在執行程序中，一旦出現例外，就會生成一個對應例外類的物件，根據此物件的型別，去catch中進行匹配
一旦try中的例外物件匹配到某一個catch時，就進入catch中進行例外的處理，一旦處理完成，就跳出當前的
try-catch結構（在沒有寫finally的情況），繼續執行其后的代碼
catch中的例外型別如果沒有子父類關系，則誰宣告在上，誰宣告在下無所謂，
catch中的例外型別如果滿足子父類關系，則要求子類一定宣告在父類的上面，否則，報錯
常用的例外物件處理的方式： ① String getMessage() ② printStackTrace()
在try結構中宣告的變數，再出了try結構以后，就不能再被呼叫
try-catch-finally結構可以嵌套
finally中宣告的是一定會被執行的代碼，即使catch中又出現例外了，try中有return陳述句，catch中有return陳述句等情況，
像資料庫連接、輸入輸出流、網路編程Socket等資源，JVM是不能自動的回收的，我們需要自己手動的進行資源的釋放，此時的資源釋放，就需要宣告在finally中，

示例一：

@Test
public void test1(){
    String str = "abcd";
    int num = 1314;
    try {
        num = Integer.parseInt(str);

        System.out.println("進入try代碼塊!");
    }catch (NumberFormatException e){
        System.out.println("出現數值轉換例外了！");
        System.out.println(e.getMessage());
        e.printStackTrace();
        System.out.println("該catch陳述句塊將要執行完了！");
    } catch (NullPointerException e){
        System.out.println("出現空指標例外！");
    } catch (Exception e){
        System.out.println("出現例外了");
    }finally {
        System.out.println("執行finally陳述句了！");
    }
    System.out.println(num);
}

輸出結果：

在這里插入圖片描述

示例二：

    @Test
    public void test2(){
        File file = new File("a.txt");
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            int date = fis.read();
            while(date != -1){
                System.out.println((char)date);
                date = fis.read();
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            System.out.println("執行finally陳述句了！");
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

輸出結果：
在這里插入圖片描述

總結：

使用try-catch-finally處理編譯時例外，是得程式在編譯時就不再報錯，但是運行時仍可能報錯，相當于我們使用try-catch-finally將一個編譯時可能出現的例外，延遲到運行時出現，
開發中，由于運行時例外比較常見，所以我們通常就不針對運行時例外撰寫try-catch-finally了，針對于編譯時例外，我們說一定要考慮例外的處理，

3.throws + 例外型別的使用

"throws + 例外型別"寫在方法的宣告處，指明此方法執行時，可能會拋出的例外型別，一旦當方法體執行時，出現例外，仍會在例外代碼處生成一個例外類的物件，此物件滿足throws后例外型別時，就會被拋出，例外代碼后續的代碼，就不再執行！
try-catch-finally:真正的將例外給處理掉了，
throws的方式只是將例外拋給了方法的呼叫者，并沒有真正將例外處理掉，
子類重寫的方法拋出的例外型別不大于父類被重寫的方法拋出的例外型別（子類重寫的方法也可以不拋出例外）

public class SuperClass {
    public void method() throws IOException {

    }
}

class SubClass extends SuperClass{
    //報錯，子類重寫的方法拋出的例外型別不大于父類被重寫的方法拋出的例外型別
//    public void method() throws Exception{
//
//    }

    public void method() throws FileNotFoundException{

    }
}

開發中如何選擇使用try-catch-finally 還是使用throws？
- 如果父類中被重寫的方法沒有throws方式處理例外，則子類重寫的方法也不能使用throws，意味著如果
  子類重寫的方法中有例外，必須使用try-catch-finally方式處理，
- 執行的方法a中，先后又呼叫了另外的幾個方法，這幾個方法是遞進關系執行的，我們建議這幾個方法使用throws
  的方式進行處理，而執行的方法a可以考慮使用try-catch-finally方式進行處理，

代碼示例：

public class ErrorThrows {
    public static void method1() throws IOException {
        File file = new File("a.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        
        int data = fileInputStream.read();
        while(data != -1){
            System.out.println((char)data);
            data = fileInputStream.read();
        }
        fileInputStream.close();
    }
    
    public static void method2() throws IOException {
        method1();
    }
    
    public static void method3() throws IOException {
        method1();
    }

    public static void main(String[] args) {
        try {
            method3();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.手動拋出一個例外類物件(throw關鍵字使用)

代碼示例：

public class ReturnException {
    static void method1(){
        try{
            System.out.println("進入方法1");
            throw new RuntimeException("手動拋出例外");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println(e.getMessage());
        } finally {
            System.out.println("執行finally陳述句了！");
        }
    }

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

輸出結果：
在這里插入圖片描述

四.自定義例外類

自定義例外類，有如下三步驟：

繼承于現有的例外結構：RuntimeException 、Exception
提供全域常量：serialVersionUID
提供多載的構造器

自定義例外類：

public class MyExceptionClass extends Exception{

    static final long serialVersionUID = -5641210210148784L;

    public MyExceptionClass() {
    }

    public MyExceptionClass(String message) {
        super(message);
    }
}

手動拋出上述自定義的例外類物件：

public class MyExceptionTest {

    static void method1() throws MyExceptionClass {
        Scanner scanner = new Scanner(System.in);

        System.out.println("請輸入大于0的資料：");
        double next = scanner.nextDouble();
        if(next >0){
            System.out.println("您輸入的資料為："+next);
        }else {
            throw new MyExceptionClass("您輸入的資料不滿足要求！");
        }
    }

    public static void main(String[] args) {
        try {
            method1();
        } catch (MyExceptionClass myExceptionClass) {
            myExceptionClass.printStackTrace();
        }
    }
}

運行結果：
在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/225841.html

標籤：java

上一篇：Flink處理函式實戰之三：KeyedProcessFunction類

下一篇：淺談static用法