你是否曾遇到過這樣的場景：辛辛苦苦寫了幾百行 Java 代碼，運行時卻突然彈出一行刺眼的紅色文字，程序直接崩潰？別慌，這其實是 Java 在 “善意提醒”—— 你的代碼出了點小狀況，而這個 “提醒” 就是我們今天要深入探討的主角 ——異常（Exception）。

作為 Java 開發(fā)者，掌握異常處理不僅能讓你的程序更健壯，還能在調試時少走彎路。今天這篇文章，我們就從理論到實踐，全方位剖析 Java 異常，讓你從此面對異常不再手足無措！

一、什么是 Java 異常？

簡單來說，異常就是程序運行過程中出現(xiàn)的意外情況。比如你寫了一段讀取文件的代碼，但運行時發(fā)現(xiàn)這個文件被刪除了；或者你想把字符串轉換成數(shù)字，卻不小心傳入了字母 —— 這些都會導致異常。

舉個生活中的例子：你去自動取款機取錢，正常流程是插卡、輸密碼、取錢、退卡。但如果中途銀行卡被吞了（機器故障），或者密碼輸錯三次被鎖定（操作錯誤），這些 “意外情況” 就相當于程序中的 “異?！?。此時取款機不會一直卡在那里，而是會提示你 “卡已被吞，請聯(lián)系銀行”，這其實就是一種 “異常處理”。

在 Java 中，異常本質上是一個對象，它繼承自Throwable類。當異常發(fā)生時，Java 虛擬機會創(chuàng)建一個異常對象，并停止當前的執(zhí)行流程，轉而尋找能處理這個異常的代碼 —— 這個過程叫做 “拋出異常（throw）” 和 “捕獲異常（catch）”。

二、異常的 “家族圖譜”：三類異常你必須分清

Java 的異常體系就像一個大家族，從上到下分了多個層級，最核心的有三類：

1. 檢查型異常（Checked Exception）

這類異常是編譯器 “強制要求” 你處理的，如果你不處理，代碼根本編譯不過。它們通常是由外部因素引起的，比如文件不存在、網絡連接失敗等。

典型代表：

• IOException（輸入輸出異常）：涵蓋了大量與輸入輸出相關的異常，如文件讀寫錯誤、網絡傳輸錯誤等。
• FileNotFoundException（文件未找到異常）：當試圖訪問的文件不存在時拋出。
• SQLException（數(shù)據庫操作異常）：在進行數(shù)據庫連接、查詢、更新等操作時可能出現(xiàn)，如數(shù)據庫連接失敗、SQL 語句語法錯誤等。
• ClassNotFoundException（類未找到異常）：當程序試圖加載一個不存在的類時拋出，常見于反射機制中。
• InterruptedException（中斷異常）：當線程在睡眠、等待等狀態(tài)時被中斷，就會拋出該異常。
• ParseException（解析異常）：在解析字符串為特定格式（如日期格式）時，如果格式不匹配則會拋出，例如使用SimpleDateFormat解析日期字符串出錯。

2. 非檢查型異常（Unchecked Exception）

編譯器不會強制你處理這類異常，它們通常是由代碼邏輯錯誤導致的，比如數(shù)組越界、空指針調用等。

典型代表：

• NullPointerException（空指針異常）：當調用一個null對象的方法或訪問其屬性時拋出，是最常見的異常之一。
• IndexOutOfBoundsException（索引越界異常）：包括數(shù)組索引越界和集合索引越界等情況，如訪問數(shù)組時索引值超出范圍。
• ArrayIndexOutOfBoundsException（數(shù)組索引越界異常）：專門針對數(shù)組的索引越界情況。
• StringIndexOutOfBoundsException（字符串索引越界異常）：操作字符串時，索引超出字符串長度范圍拋出。
• ArithmeticException（算術異常）：發(fā)生非法算術運算時拋出，最常見的情況是除以 0。
• ClassCastException（類型轉換異常）：當試圖將一個對象強制轉換為不兼容的類型時拋出，例如將字符串對象強制轉換為整數(shù)對象。
• IllegalArgumentException（非法參數(shù)異常）：當方法接收到的參數(shù)不符合預期要求時拋出，通常由開發(fā)者主動拋出以提示參數(shù)錯誤。
• NumberFormatException（數(shù)字格式異常）：將字符串轉換為數(shù)字時，如果字符串格式不符合數(shù)字要求則拋出，如Integer.parseInt("123a")。
• NoSuchElementException（無此元素異常）：在操作集合的迭代器時，試圖訪問不存在的元素會拋出該異常。
• ConcurrentModificationException（并發(fā)修改異常）：當使用迭代器遍歷集合的同時，對集合進行修改（添加或刪除元素）時拋出。

3. 錯誤（Error）

這是最嚴重的問題，通常是由 Java 虛擬機本身出現(xiàn)故障引起的，比如內存溢出、棧溢出等。這類問題程序員一般無法通過代碼處理，只能從硬件或環(huán)境層面解決。

典型代表：

• OutOfMemoryError（內存溢出錯誤）：當程序需要的內存超過了 Java 虛擬機所能分配的最大內存時拋出，可能是由于創(chuàng)建了過多大對象、內存泄漏等原因導致。
• StackOverflowError（棧溢出錯誤）：當方法調用層次過深，導致棧內存被耗盡時拋出，比如遞歸調用沒有正確的終止條件。
• NoClassDefFoundError（類定義未找到錯誤）：當虛擬機在運行時找不到某個類的定義時拋出，可能是類文件被刪除、類路徑配置錯誤等原因導致，與ClassNotFoundException不同，它是在編譯時存在該類，運行時卻找不到。
• UnsupportedClassVersionError（不支持的類版本錯誤）：當 Java 虛擬機試圖加載的類所使用的類文件版本高于當前虛擬機支持的版本時拋出。
• InternalError（內部錯誤）：表示 Java 虛擬機內部出現(xiàn)了錯誤，通常是虛擬機本身的問題。

記住一個關鍵點：我們日常開發(fā)中需要重點處理的是前兩類異常，尤其是檢查型異常和常見的非檢查型異常。

三、異常處理的 “三板斧”：try-catch-finally

當異常發(fā)生時，Java 提供了一套標準的處理機制 ——try-catch-finally，這三者配合使用，能讓程序在遇到異常時 “優(yōu)雅降級”，而不是直接崩潰。

基本語法：

try {
   // 可能發(fā)生異常的代碼塊
} catch (異常類型1 異常對象) {

   // 處理異常類型1的代碼
} catch (異常類型2 異常對象) {

   // 處理異常類型2的代碼
} finally {
   // 無論是否發(fā)生異常，都會執(zhí)行的代碼（比如釋放資源）
}

實例 1：用 try-catch 捕獲算術異常

public class ExceptionDemo {
   public static void main(String\[] args) {
       int a = 10;
       int b = 0;
       
       try {
           // 這里可能發(fā)生除以0的異常
           int result = a / b;
           System.out.println("結果是：" + result);
       } catch (ArithmeticException e) {
           // 捕獲并處理算術異常
           System.out.println("出錯了：" + e.getMessage()); // 輸出異常信息
           e.printStackTrace(); // 打印異常堆棧信息，方便調試
       } finally {
           System.out.println("無論是否發(fā)生異常，我都會執(zhí)行！");
       }
       System.out.println("程序繼續(xù)執(zhí)行..."); // 如果異常被捕獲，這句會正常輸出
   }
}

運行結果：

出錯了：/ by zero
java.lang.ArithmeticException: / by zero
   at ExceptionDemo.main(ExceptionDemo.java:8)
無論是否發(fā)生異常，我都會執(zhí)行！
程序繼續(xù)執(zhí)行...

代碼解析：

• try塊：包裹可能發(fā)生異常的代碼。這里執(zhí)行10/0時，必然會拋出ArithmeticException。
• catch塊：當try塊中發(fā)生指定類型的異常時，就會執(zhí)行這里的代碼。我們可以通過異常對象e獲取異常信息，比如e.getMessage()返回異常描述，e.printStackTrace()打印完整的堆棧軌跡（強烈建議調試時使用）。
• finally塊：無論try塊是否發(fā)生異常，這里的代碼一定會執(zhí)行。它通常用于釋放資源，比如關閉文件流、數(shù)據庫連接等。

四、主動拋出異常：throw 和 throws 的用法

有時候，我們需要在代碼中主動拋出異常，比如當方法的參數(shù)不符合要求時。這時就需要用到throw和throws關鍵字。

1. throw：在方法內部主動拋出異常

public class ThrowDemo {
   public static void checkAge(int age) {
       if (age < 0 || age > 150) {
           // 當年齡不合法時，主動拋出IllegalArgumentException
           throw new IllegalArgumentException("年齡必須在0-150之間，你輸入的是：" + age);
       }
       System.out.println("年齡合法：" + age);
   }

   public static void main(String\[] args) {
       try {
           checkAge(200); // 調用方法時可能會觸發(fā)異常
       } catch (IllegalArgumentException e) {
           System.out.println("捕獲到異常：" + e.getMessage());
       }
   }
}

運行結果：

捕獲到異常：年齡必須在0-150之間，你輸入的是：200

2. throws：聲明方法可能拋出的異常

如果一個方法內部可能會拋出檢查型異常，而你不想在方法內部處理，就可以用throws在方法聲明處告訴調用者 “這個方法可能會拋出這些異常，你需要處理”。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class ThrowsDemo {
   // 聲明方法可能拋出FileNotFoundException（檢查型異常）
   public static void readFile(String filePath) throws FileNotFoundException {
       // 讀取文件的操作可能會拋出FileNotFoundException
       File file = new File(filePath);
       FileInputStream fis = new FileInputStream(file);
   }

   public static void main(String\[] args) {
       try {
           readFile("不存在的文件.txt"); // 調用者必須處理聲明的異常
       } catch (FileNotFoundException e) {
           System.out.println("文件找不到：" + e.getMessage());
       }
   }
}

注意：如果方法聲明了throws檢查型異常，調用者必須用try-catch處理，或者繼續(xù)用throws向上傳遞，否則編譯報錯。

五、實戰(zhàn)避坑：這些常用異常你一定遇到過！

1. 空指針異常（NullPointerException）

最常見的異常沒有之一！當你調用一個null對象的方法或屬性時就會觸發(fā)。

錯誤示例：

String str = null;
System.out.println(str.length()); // 報錯：NullPointerException

避坑技巧：調用方法前先判斷對象是否為null，或使用 Java 8 的Optional類進行處理：

// 傳統(tǒng)判斷
if (str != null) {
   System.out.println(str.length());
}
// 使用Optional
Optional\<String> optionalStr = Optional.ofNullable(str);
optionalStr.ifPresent(s -> System.out.println(s.length()));

2. 數(shù)組索引越界異常（ArrayIndexOutOfBoundsException）

當訪問數(shù)組時，索引值小于 0 或大于等于數(shù)組長度時觸發(fā)。

錯誤示例：

int\[] arr = {1, 2, 3};
System.out.println(arr\[3]); // 數(shù)組長度為3，索引最大是2，這里報錯

避坑技巧：訪問數(shù)組前先檢查索引范圍：

int index = 3;
if (index >= 0 && index < arr.length) {
   System.out.println(arr\[index]);
} else {
   System.out.println("索引超出范圍");
}

3. 類型轉換異常（ClassCastException）

當試圖將一個對象強制轉換為不兼容的類型時觸發(fā)。

錯誤示例：

Object obj = "hello";
Integer num = (Integer) obj; // 字符串不能轉換為Integer，報錯

避坑技巧：轉換前用instanceof判斷類型是否兼容：

Object obj = "hello";
if (obj instanceof Integer) {
   Integer num = (Integer) obj;
} else {
   System.out.println("類型不兼容，無法轉換");
}

4. 數(shù)字格式異常（NumberFormatException）

將字符串轉換為數(shù)字時，如果字符串格式不符合數(shù)字要求，就會拋出該異常。

錯誤示例：

String numStr = "123a";
int num = Integer.parseInt(numStr); // 報錯：NumberFormatException

避坑技巧：轉換前先驗證字符串格式：

String numStr = "123a";
if (numStr.matches("\\\d+")) {
   int num = Integer.parseInt(numStr);
} else {
   System.out.println("字符串格式不符合數(shù)字要求");
}

5. 算術異常（ArithmeticException）

發(fā)生非法算術運算時拋出，最常見的情況是除以 0。

錯誤示例：

int a = 10;
int b = 0;
int result = a / b; // 報錯：ArithmeticException

避坑技巧：進行除法運算前，判斷除數(shù)是否為 0：

int a = 10;
int b = 0;
if (b != 0) {
   int result = a / b;
} else {
   System.out.println("除數(shù)不能為0");
}

6. 輸入輸出異常（IOException）

這是一個檢查型異常，在進行文件讀寫、網絡操作等輸入輸出操作時可能會拋出，比如文件不存在、權限不足等。

錯誤示例：

// 未處理檢查型異常，編譯報錯
FileReader fileReader = new FileReader("test.txt");

避坑技巧：使用try-catch處理或在方法上聲明throws，并確保資源正確關閉：

try (FileReader fileReader = new FileReader("test.txt")) {
   // 讀取文件操作
} catch (FileNotFoundException e) {
   System.out.println("文件不存在：" + e.getMessage());
} catch (IOException e) {
   System.out.println("文件讀取錯誤：" + e.getMessage());
}

7. 非法參數(shù)異常（IllegalArgumentException）

當方法接收到的參數(shù)不符合預期要求時拋出，通常由開發(fā)者主動拋出。

錯誤示例：

public static void setAge(int age) {
   if (age < 0) {
       throw new IllegalArgumentException("年齡不能為負數(shù)");
   }
}
// 調用時傳入非法參數(shù)
setAge(-5); // 報錯：IllegalArgumentException

避坑技巧：在方法入口處對參數(shù)進行校驗，提前發(fā)現(xiàn)問題：

public static void setAge(int age) {
   if (age < 0) {
       throw new IllegalArgumentException("年齡不能為負數(shù)，傳入值：" + age);
   }
   // 正常業(yè)務邏輯
}

8. 集合為空異常（NoSuchElementException）

在操作集合（如迭代器）時，當試圖訪問不存在的元素時會拋出該異常。

錯誤示例：

List\<String> list = new ArrayList<>();
Iterator\<String> iterator = list.iterator();
System.out.println(iterator.next()); // 集合為空，報錯：NoSuchElementException

避坑技巧：操作前判斷元素是否存在：

List\<String> list = new ArrayList<>();
Iterator\<String> iterator = list.iterator();
if (iterator.hasNext()) {
   System.out.println(iterator.next());
} else {
   System.out.println("集合中沒有元素");
}

9. 并發(fā)修改異常（ConcurrentModificationException）

當使用迭代器遍歷集合時，同時修改集合（如添加或刪除元素）會拋出該異常。

錯誤示例：

List\<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
for (String s : list) {
   if (s.equals("b")) {
       list.remove(s); // 報錯：ConcurrentModificationException
   }
}

避坑技巧：使用迭代器的remove方法，或使用Stream操作：

// 使用迭代器的remove方法
Iterator\<String> iterator = list.iterator();
while (iterator.hasNext()) {
   String s = iterator.next();
   if (s.equals("b")) {
       iterator.remove();
   }
}
// 使用Stream過濾
List\<String> newList = list.stream().filter(s -> !s.equals("b")).collect(Collectors.toList());

10. 類未找到異常（ClassNotFoundException）

當試圖加載一個不存在的類時拋出，常見于反射操作中。

錯誤示例：

Class.forName("com.example.NonExistentClass"); // 報錯：ClassNotFoundException

避坑技巧：確保類名和包名正確，檢查類路徑是否包含該類：