詳解Java異常處理的使用與思考

更新時(shí)間：2023年04月10日 08:21:31 作者：小二十七

異常處理的概念起源于早期的編程語言，如?LISP、PL/I?和?CLU。這些編程語言首次引入了異常處理機(jī)制，以便在程序執(zhí)行過程中檢測(cè)和處理錯(cuò)誤情況。本文主要來介紹一下Java中的異常處理，需要的可以參考一下

概念

異常處理的概念起源于早期的編程語言，如 LISP、PL/I 和 CLU。這些編程語言首次引入了異常處理機(jī)制，以便在程序執(zhí)行過程中檢測(cè)和處理錯(cuò)誤情況。異常處理機(jī)制隨后在 Ada、Modula-3、C++、Python、Java 等編程語言中得到了廣泛采用和發(fā)展。在 Java 中，異常處理是提供一種在程序運(yùn)行時(shí)處理錯(cuò)誤和異常情況的方法。異常處理機(jī)制使得程序能夠在遇到錯(cuò)誤時(shí)繼續(xù)執(zhí)行，而不是立即崩潰。這種機(jī)制使程序更具有健壯性和容錯(cuò)性。異常分為兩類：受檢異常（Checked Exceptions）和非受檢異常（Unchecked Exceptions）

受檢異常（Checked Exceptions）：

受檢異常是指那些在編譯時(shí)必須處理的異常。它們通常是由程序員的錯(cuò)誤或外部資源問題引起的。例如，IOException、FileNotFoundException 等。受檢異常必須在方法簽名中使用 throws 關(guān)鍵字聲明，或者在方法體內(nèi)用 try-catch 塊捕獲和處理。

非受檢異常（Unchecked Exceptions）：

非受檢異常是指那些在編譯時(shí)不強(qiáng)制要求處理的異常。它們通常是由編程錯(cuò)誤引起的，如空指針異常（NullPointerException）、數(shù)組越界（ArrayIndexOutOfBoundsException）等。非受檢異常繼承自 java.lang.RuntimeException 類，不需要在方法簽名中聲明，也不需要強(qiáng)制捕獲和處理。

它們的關(guān)系如下：

異常處理

Java 使用 try/catch 關(guān)鍵字進(jìn)行異常捕獲，使用 throw 聲明拋出異常，示例代碼如下：

public class NullPointerExceptionExample {
    public static void main(String[] args) {
        String nullString = null;
        try {
            int length = nullString.length();
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException!");
            e.printStackTrace();
        }
    }
}

在這個(gè)示例中，我們嘗試獲取一個(gè) null 字符串的長度。當(dāng)調(diào)用 nullString.length() 時(shí)，會(huì)拋出 NullPointerException。我們使用 try-catch 語句捕獲異常并處理它

自定義異常

Java 官方異常不可能預(yù)見所有可能發(fā)生的錯(cuò)誤，有時(shí)候你需要結(jié)合自己的業(yè)務(wù)場(chǎng)景，例如以下場(chǎng)景：

當(dāng)內(nèi)置的 Java 異常類無法準(zhǔn)確描述你所遇到的異常情況時(shí)。
需要為特定領(lǐng)域或業(yè)務(wù)邏輯創(chuàng)建一組特定的異常。
當(dāng)希望通過自定義異常類向調(diào)用者提供更多的上下文信息或特定的錯(cuò)誤代碼時(shí)。

構(gòu)建特定的異常，這也很簡(jiǎn)單，繼承已有的異常類（最好繼承含義差不多的），如下，我們創(chuàng)建一個(gè)表示賬戶余額不足的異常：

public class InsufficientBalanceException extends RuntimeException {
    private double balance;
    private double amount;

    public InsufficientBalanceException(double balance, double amount) {
        super("Insufficient balance: " + balance + ", required amount: " + amount);
        this.balance = balance;
        this.amount = amount;
    }

    public double getBalance() {
        return balance;
    }

    public double getAmount() {
        return amount;
    }
}

接下來，我們?cè)跇I(yè)務(wù)邏輯代碼中使用這個(gè)自定義異常：

public class BankAccount {
    private double balance;

    public BankAccount(double balance) {
        this.balance = balance;
    }

    public void withdraw(double amount) throws InsufficientBalanceException {
        if (amount > balance) {
            throw new InsufficientBalanceException(balance, amount);
        }
        balance -= amount;
    }
}

調(diào)用者可以捕獲并處理這個(gè)自定義異常：

public class BankAccountTest {
    private static final Logger logger = Logger.getLogger(BankAccountTest.class.getName());

    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000.00);
        try {
            account.withdraw(2000.00);
        } catch (InsufficientBalanceException e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println("Current balance: " + e.getBalance());
            System.out.println("Required amount: " + e.getAmount());
            
            logger.log(Level.SEVERE, "An exception occurred", e);
        }
    }
}

可以看到自定義異常使我們能夠更清晰地表達(dá)業(yè)務(wù)邏輯中可能出現(xiàn)的異常情況，同時(shí)為調(diào)用者提供更多關(guān)于異常的上下文信息。我們還使用 java.util.logging 工具將輸出記錄到日志中

多重捕獲

在 Java 早起版本，處理多個(gè)沒有共同基類的異常，需要為每一個(gè)異常類型編寫一個(gè) catch 語句處理，如下：

class CustomException1 extends Exception {
    public CustomException1(String message) {
        super(message);
    }
}

class CustomException2 extends Exception {
    public CustomException2(String message) {
        super(message);
    }
}

public class SingleCatchException {

    public static void main(String[] args) {
        try {
            // 根據(jù)參數(shù)選擇拋出哪種異常
            if (args.length > 0 && "type1".equals(args[0])) {
                throw new CustomException1("This is a custom exception type 1.");
            } else {
                throw new CustomException2("This is a custom exception type 2.");
            }
        } catch (CustomException1 e) {
            // 當(dāng) CustomException1 發(fā)生時(shí)，執(zhí)行此代碼塊
            System.err.println("Error occurred: " + e.getMessage());
        } catch (CustomException2 e) {
            // 當(dāng) CustomException2 發(fā)生時(shí)，執(zhí)行此代碼塊
            System.err.println("Error occurred: " + e.getMessage());
        }
    }
}

這樣的代碼不僅難以閱讀，而且也不夠簡(jiǎn)潔。

多重異常捕獲機(jī)制，它允許在一個(gè) catch 語句中捕獲多個(gè)異常類型。這種方法可以避免重復(fù)的代碼，使異常處理更加簡(jiǎn)潔。以下是一個(gè)使用多重異常捕獲機(jī)制的示例：

public class MultiCatchExample {

    public static void main(String[] args) {
        try {
            // 根據(jù)參數(shù)選擇拋出哪種異常
            if (args.length > 0 && "type1".equals(args[0])) {
                throw new CustomException1("This is a custom exception type 1.");
            } else {
                throw new CustomException2("This is a custom exception type 2.");
            }
        } catch (CustomException1 | CustomException2 e) {
            // 當(dāng) CustomExceptionType1 或 CustomExceptionType2 發(fā)生時(shí)，執(zhí)行此代碼塊
            System.err.println("Error occurred: " + e.getMessage());
        }
    }
}

重新拋出異常

在某些情況下，你可能希望將異常傳遞給調(diào)用者處理，而不是在當(dāng)前方法中處理?；蛘咝枰诓东@異常時(shí)執(zhí)行一些處理操作，如記錄日志、清理資源或者添加額外的上下文信息。在這種情況下，你可以在 catch 塊中處理異常，然后重新拋出原始異常或拋出一個(gè)新的異常，包含額外的信息，如下：

public class RethrowExceptionExample {
    public static void main(String[] args) {
        try {
            doSomething();		// 可能會(huì)拋出異常的方法
        } catch (IOException e) {
            // 異常處理邏輯
            System.err.println("An error occurred: " + e.getMessage());            
            // 重新拋出異常
            throw e;
        }
    }
}

更好的 NPE

NPE（NullPointerExceptions）是很常見異常，在 JDK 14 以前遇到 NPE 異常，能得到信息有限，JDK 15 引入了一項(xiàng)名為“Helpful NullPointerExceptions”的新功能，這項(xiàng)功能改進(jìn)了 NullPointerException (NPE) 的診斷。在之前的 JDK 版本中，當(dāng)發(fā)生 NullPointerException 時(shí)，異常信息通常并不提供足夠的上下文來幫助開發(fā)人員定位問題的具體位置。

示例代碼：

class A {
    String s;
    public A(String s) {
        this.s = s;
    }
}

class B {
    A a;
    public B(A a) {
        this.a = a;
    }
}

class C {
    B b;
    public C(B b) {
        this.b = b;
    }
}

public class BetterNullPointerReports {

    public static void main(String[] args) {
        C[] ca = {
                new C(new B(new A(null))),
                new C(new B(null)),
                new C(null)
        };

        for (C c : ca) {
            try {
                System.out.println(c.b.a.s);
            } catch (NullPointerException npe) {
                System.out.println(npe);
            }
        }
    }
}

在 JDK 14 及之前的版本中，輸出結(jié)果：

# 你根本看不出哪里出了問題
null
java.lang.NullPointerException
java.lang.NullPointerException

在 JDK 15 及之后的版本中，輸出結(jié)果：

# 得到更詳細(xì)的 NPE 信息
null
java.lang.NullPointerException: Cannot read field "s" because "c.b.a" is null
java.lang.NullPointerException: Cannot read field "a" because "c.b" is null

清道夫：finally

當(dāng)程序發(fā)生了非預(yù)期的異常，那么程序會(huì)終止運(yùn)行，但是對(duì)于很多需要執(zhí)行清理操作，這是不可接受的，例如：

關(guān)閉資源：在 try 塊中打開的資源，如文件、數(shù)據(jù)庫連接、網(wǎng)絡(luò)連接等，需要在完成操作后確保被正確關(guān)閉
釋放鎖：在并發(fā)編程中，可能會(huì)使用鎖來同步代碼。在釋放鎖之前，如果發(fā)生異常，可能會(huì)導(dǎo)致其他線程無法獲取鎖
回滾事務(wù)：在數(shù)據(jù)庫編程中，可能需要在事務(wù)中執(zhí)行一系列操作。如果這些操作中的任何一個(gè)失敗，事務(wù)需要回滾
恢復(fù)狀態(tài)：在執(zhí)行某些操作時(shí)，可能需要更改對(duì)象或系統(tǒng)的狀態(tài)。在操作完成后，可能需要恢復(fù)原始狀態(tài)

對(duì)于以上的程序來說，finally 就非常重要了，它可以解決以上程序的清理操作。

示例代碼：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FinallyExample {

    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("example.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    System.err.println("Error closing file: " + e.getMessage());
                }
            }
        }
    }
}

在以上代碼中，無論程序是否出錯(cuò)，finally 都可以確保文件被正確關(guān)閉

異常的約束

Java 在面向?qū)ο笾袑?duì)異常存在頗多約束和限制，其主要目的如下：

保持子類型可替換性：當(dāng)子類覆蓋父類的方法或?qū)崿F(xiàn)接口的方法時(shí)，子類的方法應(yīng)該滿足父類或接口方法的約定
避免意外的異常：如果子類方法可以拋出任意異常，那么調(diào)用者在處理異常時(shí)可能遇到意外的異常類型，導(dǎo)致程序出錯(cuò)
提高代碼可讀性：通過限制異常的繼承和實(shí)現(xiàn)規(guī)則，可以使得代碼更加清晰和易于理解
促進(jìn)良好的設(shè)計(jì)實(shí)踐：如果子類方法可以拋出任意異常，那么程序員可能會(huì)過度依賴異常來處理錯(cuò)誤情況，導(dǎo)致代碼難以維護(hù)

在接口和繼承中使用異常，需要遵循以下規(guī)則：

子類可以拋出與接口或者父類方法相同的異常。
子類可以不拋出任何異常，即使接口或父類方法聲明了異常。這意味著實(shí)現(xiàn)類的方法已經(jīng)處理了這些異常。
子類可以拋出接口方法或父類聲明異常的相同類型的異常，因?yàn)樽宇惍惓Ｒ廊环辖涌诜椒ǖ募s定。

代碼示例：

class CustomException extends RuntimeException {}
class CustomExceptionChild extends CustomException {}
interface MyInterface {
    void myMethod() throws CustomException;
}

class MyClass1 implements MyInterface {
    // 1：拋出與接口方法相同異常
    @Override
//    public void myMethod() throws FileNotFoundException {     // 編譯錯(cuò)誤，不能拋出不同類型的異常
    public void myMethod() throws CustomException {
        // ...
    }
}

class MyClass2 implements MyInterface {
    // 2：即使不拋出任何異常，也沒有問題
    @Override
    public void myMethod() {
    }
}

class MyClass3 implements MyInterface {
    // 3: 拋出接口方法聲明異常的子類異常（或者父類，既相同類型即可）
    @Override
    public void myMethod() throws CustomExceptionChild {
        // ...
    }
}

try-with-resources

在 Java 7 中，關(guān)于自動(dòng)管理資源。在處理需要關(guān)閉的資源（如文件、數(shù)據(jù)庫連接、網(wǎng)絡(luò)連接等）有了更好的選擇，那就是使用 try-catch-finally 進(jìn)行處理，它對(duì)比 finally 具有以下優(yōu)勢(shì)：

簡(jiǎn)化代碼：相比 finally 顯示關(guān)閉資源，使用 Try-With-Resources，可以自動(dòng)關(guān)閉資源，從而使代碼更簡(jiǎn)潔、易讀。
避免資源泄漏：使用 Try-With-Resources 能夠確保在退出 try 代碼塊時(shí)自動(dòng)關(guān)閉資源，降低資源泄漏的風(fēng)險(xiǎn)。
減少錯(cuò)誤：Try-With-Resources 能夠正確地處理資源關(guān)閉過程中的異常，并提供完整的異常信息，有助于減少錯(cuò)誤。

示例代碼：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {

    public static void main(String[] args) {
        String fileName = "example.txt";

        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
    }
}

在這個(gè)示例中，我們使用 Try-With-Resources 語句創(chuàng)建了一個(gè) BufferedReader 實(shí)例。BufferedReader 實(shí)現(xiàn)了 Closeable 接口，因此在退出 try 代碼塊時(shí)，reader 會(huì)自動(dòng)調(diào)用 close() 方法以釋放資源。

為了一探 Try-With-Resources 的究竟，我們可以創(chuàng)建自定義的 AutoCloseable 類：

class Reporter implements AutoCloseable {
    String name = getClass().getSimpleName();
    public Reporter() {
        System.out.println("Creating " + name);
    }
    @Override
    public void close() throws Exception {
        System.out.println("Closing " + name);
    }
}
class First extends Reporter {}
class Second extends Reporter {}

public class AutoCloseableDetails {
    public static void main(String[] args) {
        try (First f = new First(); Second s = new Second()) {
            System.out.println("In body");
        } catch (Exception e) {
            System.out.println("Exception caught");
        }
    }
}

輸出結(jié)果：

Creating First
Creating Second
In body
Closing Second
Closing First

退出 try 塊會(huì)調(diào)用兩個(gè)對(duì)象的 close() 方法，并以與創(chuàng)建順序相反的順序關(guān)閉它們。（順序很重要）。

使用 Try-With-Resource 是很安全的，假設(shè)你隨意在 Try 頭使用對(duì)象，會(huì)出現(xiàn)編譯錯(cuò)誤：

class Anything {}

public class TryAnything {
    public static void main(String[] args) {
        // 假設(shè)我們定義的類，不是 AutoCloseable 的對(duì)象，會(huì)出現(xiàn)編譯錯(cuò)誤
        try (Anything a = new Anything()) {     // compile error
            System.out.println("In body");
        } catch (Exception e) {
            System.out.println("Exception caught");
        }
    }
}

異常類型匹配

Java 在拋出異常時(shí)，會(huì)根據(jù)異常類型進(jìn)行匹配。異常處理程序會(huì)從上到下依次檢查 catch 子句，看它們是否與拋出的異常類型兼容。當(dāng)發(fā)現(xiàn)兼容的 catch 子句時(shí)，Java 就會(huì)執(zhí)行該子句的代碼來處理異常。請(qǐng)注意，Java 只會(huì)執(zhí)行與拋出異常類型兼容的第一個(gè) catch 子句。

示例代碼：

public class ExceptionMatchingExample {
    public static void main(String[] args) {
        try {
            // ... Some code that may throw exceptions ...
            throw new FileNotFoundException("File not found");
        } catch (FileNotFoundException e) {
            System.out.println("Handling FileNotFoundException: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Handling IOException: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Handling general exception: " + e.getMessage());
        }
    }
}

在這個(gè)示例中，我們拋出了一個(gè) FileNotFoundException，Java 會(huì)從上到下檢查 catch 子句，看它們是否與 FileNotFoundException 兼容。因?yàn)?nbsp;FileNotFoundException 是 IOException 的子類，它與 FileNotFoundException 和 IOException 的 catch 子句兼容。但是，Java 只會(huì)執(zhí)行第一個(gè)兼容的 catch 子句，即 FileNotFoundException 子句。如果沒有找到兼容的 catch 子句，Java 會(huì)繼續(xù)在調(diào)用棧中查找異常處理程序，直到找到一個(gè)合適的處理程序或者程序終止。

輸出結(jié)果：

Handling FileNotFoundException: File not found

使用指南

異?？此坪?jiǎn)單易懂，但在處理過程中還需要遵循許多最佳實(shí)踐，例如：

除非你知道如何處理，否則不要捕獲異常（錯(cuò)誤處理代碼太多，容易干擾主線代碼的邏輯和可讀性）
不要生吞異常：捕獲異常不進(jìn)行處理會(huì)導(dǎo)致異常消失，從而對(duì)于線上問題排查，無從下手
捕獲具體異常：盡量捕獲具體的異常類，而不是捕獲泛化的 Exception 類
盡可能的使用多重異常捕獲來簡(jiǎn)化重復(fù)代碼，并且提高代碼的可讀性
盡可能的使用 Try-With-Resources 清理資源
自定義異常：在需要時(shí)，為特定于你的應(yīng)用程序的異常情況創(chuàng)建自定義異常

檢查型異常是 shit

檢查型異常（checked exceptions）在 Java 中引發(fā)了很多爭(zhēng)議。有些人認(rèn)為它們是一種有益的設(shè)計(jì)，可以提高代碼的可靠性，而另一些人則認(rèn)為它們是一種糟糕的設(shè)計(jì)，會(huì)導(dǎo)致代碼冗余和難以維護(hù)，例如 Martin Fowler （《UML 精粹》、《重構(gòu)》）作者，也曾在博客發(fā)表稱：

總的來說，我認(rèn)為異常很不錯(cuò)，但是 Java 的檢查型異常要比好處多

那么檢查型異常究竟帶來了什么問題？常見的槽點(diǎn)有：

強(qiáng)制錯(cuò)誤處理：檢查型異常強(qiáng)制開發(fā)者處理異常情況，導(dǎo)致主線代碼中充斥著大量和業(yè)務(wù)邏輯無關(guān)的代碼
代碼冗余：檢查型異?？赡軐?dǎo)致大量的 try-catch 代碼塊，增加代碼冗余，影響代碼可讀性
異常傳遞：對(duì)于一些需要在多層方法調(diào)用中傳遞異常的情況，檢查型異?？赡軐?dǎo)致開發(fā)者不得不為每個(gè)方法添加異常聲明

Go 也沒有異常啊

最幾年 Go 語言的成功讓很多人加深了這一觀點(diǎn)，Go 語言沒有檢查型異常的概念，但它們的代碼依然可以具有很高的可靠性。這表明檢查型異常并非是提高代碼可靠性的唯一方法。Go 語言的設(shè)計(jì)者們有意避免了引入檢查型異常，主要有以下原因：

代碼簡(jiǎn)潔性：Go 語言的設(shè)計(jì)者們希望保持代碼簡(jiǎn)潔，避免因?yàn)楫惓Ｌ幚矶a(chǎn)生的大量冗余代碼。
顯示錯(cuò)誤處理：Go 語言鼓勵(lì)開發(fā)者顯式地處理錯(cuò)誤，而不是通過異常機(jī)制隱式地處理。
降低復(fù)雜性：異常機(jī)制會(huì)增加程序的復(fù)雜性。Go 語言的設(shè)計(jì)者們希望通過避免引入異常機(jī)制，讓程序更簡(jiǎn)單易懂。
性能開銷：異常處理機(jī)制可能會(huì)帶來一定的性能開銷，通過返回 error 類型，可以避免這種性能開銷。

示例代碼：

package main

import (
    "errors"
    "fmt"
)

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }

    result, err = divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

在這個(gè)示例中，我們定義了一個(gè)名為divide的函數(shù)，它接受兩個(gè)整數(shù)參數(shù)a和b，計(jì)算它們的商。如果b為零，函數(shù)將返回一個(gè)非空的error類型值，以指示發(fā)生了錯(cuò)誤。否則，函數(shù)將返回商和一個(gè)空error值。在 main 函數(shù)中，我們調(diào)用divide兩次，一次使用一個(gè)非零除數(shù)，另一次使用零作為除數(shù)。對(duì)于第一次調(diào)用，divide將返回一個(gè)空的error值，我們就可以打印出計(jì)算結(jié)果。對(duì)于第二次調(diào)用，divide將返回一個(gè)非空的error值，我們使用if err != nil來檢查這個(gè)值是否為nil，如果不是，就打印錯(cuò)誤信息。

輸出結(jié)果：

Result: 5
Error: division by zero

以上就是 Go 在處理異常的方式。盡管 Go 語言沒有引入檢查型異常，但它依然具備了一套有效的錯(cuò)誤處理機(jī)制。使用多值返回（value, error）的方式，可以讓代碼更簡(jiǎn)潔、易讀，同時(shí)鼓勵(lì)開發(fā)者顯式地處理錯(cuò)誤。這種設(shè)計(jì)理念與 Go 語言追求簡(jiǎn)潔、高效的目標(biāo)相一致。

陳述總結(jié)

最后，關(guān)于檢查型異常在某些場(chǎng)景下可以提高代碼的可靠性和健壯性，但在另一些場(chǎng)景下可能導(dǎo)致代碼冗余和難以維護(hù)。在很多人看來弊大于利了。然而，這并不意味著在所有情況下都不應(yīng)該使用檢查型異常。在某些場(chǎng)景下，合理地使用檢查型異?？梢詭椭岣叽a的健壯性和可靠性。關(guān)鍵是要明確異常處理的目的，在實(shí)際開發(fā)中，可以根據(jù)需要和團(tuán)隊(duì)的編碼規(guī)范來權(quán)衡使用檢查型異常。

以上就是詳解Java異常處理的使用與思考的詳細(xì)內(nèi)容，更多關(guān)于Java異常處理的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: