一、throw 關鍵字

（一）基本概念與作用

throw關鍵字是Java異常處理機制中的核心組成部分，它用于在程序中主動拋出一個具體的異常對象。與系統(tǒng)自動拋出的異常不同，throw允許開發(fā)者基于業(yè)務邏輯和特定條件，手動觸發(fā)異常處理流程。

當程序運行過程中遇到以下情況時，開發(fā)者可以使用throw來手動拋出異常：

• 業(yè)務規(guī)則被違反（如賬戶余額不足）
• 參數(shù)校驗失敗
• 資源不可用
• 程序狀態(tài)異常
• 預期之外的條件發(fā)生

這種機制會立即中斷當前方法的執(zhí)行流程，并將異常對象沿著方法調用棧向上傳遞，直到被合適的catch塊捕獲處理。如果始終未被捕獲，最終會導致線程終止。

（二）語法規(guī)范與細節(jié)

完整的throw語法格式如下：

throw new 異常類名([異常信息][, 原因異常]);

其中各組成部分說明：

1. 異常類名：必須是Throwable或其子類

   • Java內置異常：如IllegalArgumentException、NullPointerException等
   • 自定義異常：需繼承Exception或RuntimeException

2. 異常信息（可選）：

   • 字符串類型，用于描述異常的具體情況
   • 可通過getMessage()方法獲取

3. 原因異常（可選）：

   • 使用異常鏈時，可以指定原始異常
   • 語法：new 異常類名("描述", causeException)

示例變體：

// 基本形式
throw new IllegalArgumentException("參數(shù)無效");
// 帶原因異常
throw new ServiceException("處理失敗", e);
// 使用預創(chuàng)建的異常對象
RuntimeException ex = new RuntimeException();
throw ex;

（三）典型應用場景

1. 參數(shù)校驗場景

當方法接收到的參數(shù)違反業(yè)務規(guī)則時拋出受檢異?；蚍鞘軝z異常：

/**
 * 設置用戶年齡
 * @param age 必須是非負整數(shù)
 * @throws IllegalArgumentException 當年齡為負數(shù)時拋出
 */
public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年齡不能為負數(shù): " + age);
    }
    this.age = age;
}

2. 狀態(tài)檢查場景

當對象處于不合適的操作狀態(tài)時：

public void withdraw(double amount) {
    if (amount <= 0) {
        throw new IllegalArgumentException("取款金額必須為正數(shù)");
    }
    if (balance < amount) {
        throw new IllegalStateException("賬戶余額不足");
    }
    balance -= amount;
}

3. 資源操作場景

當所需資源不可用時：

public void processFile(String path) throws IOException {
    File file = new File(path);
    if (!file.exists()) {
        throw new FileNotFoundException("文件不存在: " + path);
    }
    // 文件處理邏輯...
}

4. 業(yè)務規(guī)則場景

違反特定業(yè)務規(guī)則時：

public void placeOrder(Order order) {
    if (order.getItems().isEmpty()) {
        throw new EmptyOrderException("訂單不能為空");
    }
    if (!inventory.checkStock(order)) {
        throw new InsufficientStockException("庫存不足");
    }
    // 訂單處理邏輯...
}

（四）完整示例與執(zhí)行流程

基礎示例代碼

public class ThrowExample {
    /**
     * 驗證年齡有效性
     * @param age 待驗證的年齡
     * @throws IllegalArgumentException 當年齡無效時拋出
     */
    public static void validateAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("年齡不能為負數(shù): " + age);
        }
        if (age > 150) {
            throw new IllegalArgumentException("年齡超過合理范圍: " + age);
        }
        System.out.println("有效年齡: " + age);
    }
    public static void main(String[] args) {
        try {
            // 測試正常情況
            validateAge(25);
            // 測試異常情況
            validateAge(-5);
            // 這行不會執(zhí)行，因為上面已經拋出異常
            validateAge(200);
        } catch (IllegalArgumentException e) {
            System.out.println("捕獲到異常: " + e.getMessage());
            // 打印完整的異常堆棧
            e.printStackTrace();
        }
        System.out.println("程序繼續(xù)執(zhí)行...");
    }
}

執(zhí)行流程分析

1. 程序從main方法開始執(zhí)行
2. 第一次調用validateAge(25)：
   • 參數(shù)通過校驗
   • 打印"有效年齡: 25"
3. 第二次調用validateAge(-5)：
   • 觸發(fā)age < 0條件
   • 拋出IllegalArgumentException
   • 方法立即終止，控制權返回main方法
4. catch塊捕獲異常：
   • 打印異常信息
   • 打印完整堆棧軌跡
5. 繼續(xù)執(zhí)行catch塊后的代碼
6. validateAge(200)不會執(zhí)行，因為流程已被中斷

控制臺輸出示例

有效年齡: 25
捕獲到異常: 年齡不能為負數(shù): -5
java.lang.IllegalArgumentException: 年齡不能為負數(shù): -5
    at ThrowExample.validateAge(ThrowExample.java:7)
    at ThrowExample.main(ThrowExample.java:19)
程序繼續(xù)執(zhí)行...

（五）最佳實踐建議

1. 選擇合適的異常類型：

   • 對于可恢復錯誤，使用受檢異常
   • 對于編程錯誤，使用非受檢異常

2. 提供有意義的錯誤信息：

   // 差
   throw new Exception("錯誤發(fā)生");
   // 好
   throw new FileNotFoundException("無法找到配置文件: " + configPath);

3. 考慮異常鏈：

   try {
       // 可能拋出IOException的代碼
   } catch (IOException e) {
       throw new ServiceException("處理文件失敗", e);
   }
   

4. 避免過度使用：

   • 不要用異常處理常規(guī)控制流程
   • 頻繁拋出異常會影響性能

5. 文檔化異常：

   /**
    * @throws IllegalArgumentException 當輸入?yún)?shù)無效時
    * @throws IllegalStateException 當對象狀態(tài)不適合操作時
    */
   public void doSomething() {
       // 方法實現(xiàn)
   }
   

二、throws 關鍵字

（一）基本概念

throws關鍵字是Java異常處理機制的重要組成部分，用于在方法聲明處指明該方法可能拋出的異常類型。它的核心作用是：

1. 作為方法簽名的一部分，向調用者明確傳達該方法在執(zhí)行過程中可能會遇到哪些異常情況
2. 將異常處理的責任轉移給方法的調用方，實現(xiàn)異常傳播
3. 強制要求調用者處理受檢異常，提高代碼的健壯性

（二）語法格式詳解

完整的語法結構如下：

[訪問修飾符] [static] [final] [abstract] [synchronized] 返回值類型 方法名(參數(shù)列表) 
    throws 異常類型1, 異常類型2, ..., 異常類型N {
    // 方法實現(xiàn)
}

語法說明：

1. throws關鍵字必須放在方法參數(shù)列表之后，方法體之前
2. 可以聲明多個異常類型，用英文逗號分隔
3. 聲明的異常類型必須是Throwable或其子類
4. 如果方法重寫父類方法，throws聲明的異常不能比父類方法聲明的異常范圍更廣

（三）使用場景深入分析

1. 受檢異常（Checked Exception）處理：

   • 必須處理的情況：當方法內部可能拋出IOException、SQLException等受檢異常
   • 典型場景：文件操作（如FileInputStream）、數(shù)據(jù)庫操作（如JDBC）、網(wǎng)絡通信等
   • 處理方式選擇：要么在方法內用try-catch處理，要么用throws聲明

2. 非受檢異常（Unchecked Exception）處理：

   • 可選處理：RuntimeException及其子類（如NullPointerException）
   • 最佳實踐：雖然可以不聲明，但建議對重要的運行時異常進行顯式聲明
   • 框架應用：Spring等框架中常用RuntimeException聲明業(yè)務異常

3. 異常傳播場景：

   • 多層方法調用時的異常傳遞
   • 框架設計中的異常處理策略
   • 自定義異常體系的構建

（四）完整示例代碼與解析

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class ComprehensiveThrowsExample {
    /**
     * 聲明多個異常類型的示例
     * @param filePath 文件路徑
     * @throws FileNotFoundException 當文件不存在時拋出
     * @throws IOException 當發(fā)生IO錯誤時拋出
     */
    public static void processFile(String filePath) 
            throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream(filePath);
        // 模擬IO操作
        int data = fis.read();
        while(data != -1) {
            System.out.print((char)data);
            data = fis.read();
        }
        fis.close();
    }
    /**
     * 自定義異常和運行時異常示例
     * @param dateStr 日期字符串
     * @throws ParseException 當日期格式錯誤時拋出
     * @throws IllegalArgumentException 當參數(shù)不合法時拋出
     */
    public static void parseDate(String dateStr) 
            throws ParseException, IllegalArgumentException {
        if(dateStr == null || dateStr.isEmpty()) {
            throw new IllegalArgumentException("日期字符串不能為空");
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        sdf.parse(dateStr);
    }
    public static void main(String[] args) {
        try {
            // 測試文件處理方法
            processFile("config.ini");
            // 測試日期解析方法
            parseDate("2023-05-15");
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到異常: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("IO異常: " + e.getMessage());
        } catch (ParseException e) {
            System.err.println("日期解析異常: " + e.getMessage());
        } catch (IllegalArgumentException e) {
            System.err.println("參數(shù)異常: " + e.getMessage());
        } finally {
            System.out.println("\n程序執(zhí)行完畢");
        }
    }
}

代碼解析：

1. processFile方法展示了如何處理多個受檢異常
2. parseDate方法展示了受檢異常和運行時異常的混合聲明
3. main方法展示了完整的異常捕獲和處理流程
4. 包含了try-catch-finally的完整異常處理結構
5. 演示了不同類型異常的分層次處理方式

三、throw 和 throws 的區(qū)別

一、本質與作用的根本差異

（一）throw 的本質與深入解析

throw是一個執(zhí)行性語句，其核心作用是在程序運行過程中，當檢測到不符合預期的情況時，主動創(chuàng)建并拋出一個具體的異常對象，直接中斷當前的程序執(zhí)行流程。它就像一個"警報觸發(fā)器"，一旦執(zhí)行，就會立即發(fā)出異常警報，迫使程序進入異常處理流程。

具體來說，throw的工作機制包含以下關鍵點：

1. 即時性：throw語句執(zhí)行時會立即終止當前方法的繼續(xù)執(zhí)行
2. 對象創(chuàng)建：必須配合new關鍵字創(chuàng)建一個具體的異常類實例
3. 異常傳播：拋出的異常會沿著調用棧向上傳播，直到被catch捕獲或導致程序終止

例如，在一個計算除法的方法中，當除數(shù)為0時，使用throw拋出異常：

public static int divide(int a, int b) {
    if (b == 0) {
        // 創(chuàng)建并拋出ArithmeticException異常實例
        throw new ArithmeticException("除數(shù)不能為0");
        // 從這里開始后續(xù)代碼不會執(zhí)行
    }
    return a / b;
}

當b為0時，throw語句會：

1. 實例化一個ArithmeticException對象，附帶錯誤信息"除數(shù)不能為0"
2. 立即終止divide方法的執(zhí)行（return語句不會被執(zhí)行）
3. 異常對象會傳遞給調用divide方法的上層代碼

throw的典型應用場景還包括：

• 參數(shù)合法性校驗
• 業(yè)務規(guī)則違反情況
• 資源不可用狀態(tài)
• 預期外的程序狀態(tài)

（二）throws 的本質與深入解析

throws是一個聲明性標記，它的作用是在方法定義時，向方法的調用者聲明該方法在執(zhí)行過程中可能會拋出的異常類型，屬于一種"風險告知"。它本身不會拋出異常，也不會影響方法的正常執(zhí)行流程，只是提前告知調用者可能面臨的異常風險，以便調用者做好應對準備。

throws關鍵點的核心特征：

1. 聲明性而非執(zhí)行性：只是標注可能拋出的異常類型
2. 編譯時檢查：幫助編譯器進行異常處理檢查
3. 方法契約：構成方法簽名的一部分，是調用者必須知曉的接口規(guī)范

例如，一個讀取文件的方法聲明可能拋出的異常：

public static String readFileContent(String filePath) 
    throws FileNotFoundException, IOException {
    // 實際讀取文件的代碼
    // 可能拋出：
    // - FileNotFoundException 當文件不存在時
    // - IOException 當讀取過程中發(fā)生I/O錯誤時
}

throws聲明的幾個重要特點：

1. 可以聲明多個異常類型，用逗號分隔
2. 聲明的異常包括方法體內部通過throw顯式拋出的異常，以及調用的其他方法拋出的未捕獲異常
3. 對于非運行時異常(RuntimeException及其子類外的異常)，調用者必須處理或繼續(xù)聲明

throws的典型應用場景包括：

• 可能失敗的操作（如I/O操作）
• 依賴外部資源的方法
• 執(zhí)行前提條件可能不滿足的操作

通過throws聲明，方法的調用者可以清晰地了解需要處理哪些異常情況，從而編寫更健壯的代碼。

二、語法與使用位置的不同

（一）throw 的語法與位置

throw 語句只能用于方法體內部或構造器內部，用于顯式地拋出一個異常對象。其完整的語法格式為：

throw new 異常類名(異常描述信息);

其中：

• new 異常類名(異常描述信息) 用于創(chuàng)建一個具體的異常實例
• 異常描述信息是一個字符串，用于說明異常發(fā)生的原因
• throw 后面必須緊跟一個異常對象實例，不能直接跟異常類型

常見錯誤示例：

throw ArithmeticException; // 錯誤：缺少new關鍵字創(chuàng)建對象
throw "計算錯誤"; // 錯誤：不能直接拋出字符串
throw null; // 錯誤：不能拋出null

正確示例：

throw new ArithmeticException("除數(shù)不能為零"); // 拋出運行時異常
throw new FileNotFoundException("文件未找到: config.ini"); // 拋出檢查異常
throw new IllegalArgumentException("年齡不能為負數(shù): " + age); // 帶詳細錯誤信息

應用場景：

1. 在方法中檢測到非法參數(shù)時
2. 業(yè)務邏輯不滿足執(zhí)行條件時
3. 需要將底層異常轉換為更合適的異常類型時

（二）throws 的語法與位置

throws 關鍵字只能用于方法聲明的尾部，位于方法參數(shù)列表之后、方法體之前。其完整的語法格式為：

修飾符 返回值類型 方法名(參數(shù)列表) throws 異常類型1, 異常類型2, ... {
    // 方法體
}

關鍵點：

• throws 后面跟的是一個或多個異常類型
• 多個異常類型之間用逗號分隔
• 只能聲明檢查異常(checked exception)，運行時異常不需要聲明
• 子類方法重寫時，throws 的異常不能比父類方法更寬泛

正確示例：

// 聲明單個異常
public void readFile() throws IOException {
    // 讀取文件操作
}
// 聲明多個異常
public void processData() throws SQLException, ParseException {
    // 數(shù)據(jù)庫操作和日期解析
}
// 繼承中的異常聲明
class Parent {
    void demo() throws IOException {}
}
class Child extends Parent {
    @Override
    void demo() throws FileNotFoundException { // FileNotFoundException是IOException的子類
        // 實現(xiàn)代碼
    }
}

應用場景：

1. 方法內部調用了可能拋出檢查異常的方法
2. 方法內部使用throw拋出了檢查異常
3. 需要明確告知調用方可能出現(xiàn)的異常情況

三、異常處理責任的承擔方式

（一）throw 的異常處理責任

異常拋出與處理機制

當使用throw關鍵字拋出異常后，Java提供了兩種標準的異常處理途徑：

1. 在當前方法內捕獲并處理異常

   這是通過try-catch塊實現(xiàn)的本地化處理方式。這種方式適合處理那些能夠在當前方法內完全解決的異常情況。

   public static void checkNumber(int num) {
       try {
           if (num < 0) {
               throw new IllegalArgumentException("數(shù)字不能為負數(shù)");
           }
           System.out.println("輸入的數(shù)字是：" + num);
       } catch (IllegalArgumentException e) {
           System.out.println("捕獲到異常：" + e.getMessage());
           // 可以添加恢復邏輯，比如設置默認值
           System.out.println("將使用默認值0代替");
           num = 0;
       }
   }
   

2. 將異常傳遞給調用者處理

   如果當前方法不適合處理該異常，可以在方法簽名中使用throws關鍵字聲明該異常，將處理責任轉移給上層調用者。

   public static void checkNumber(int num) throws IllegalArgumentException {
       if (num < 0) {
           throw new IllegalArgumentException("數(shù)字不能為負數(shù)");
       }
       System.out.println("輸入的數(shù)字是：" + num);
   }
   

異常類型與處理要求

Java中的異常分為兩類，處理要求有所不同：

1. 受檢異常(Checked Exception)

   • 如IOException、SQLException等
   • 必須被捕獲或在方法簽名中聲明
   • 編譯器會強制檢查
   • 示例：

     public void readFile(String path) throws IOException {
         if (!new File(path).exists()) {
             throw new IOException("文件不存在");
         }
         // 文件讀取邏輯
     }
     

2. 非受檢異常(Unchecked Exception)

   • 包括RuntimeException及其子類
   • 不強制要求捕獲或聲明
   • 通常是程序邏輯錯誤
   • 示例：

     public void divide(int a, int b) {
         if (b == 0) {
             throw new ArithmeticException("除數(shù)不能為零");
         }
         System.out.println("結果：" + (a / b));
     }
     

（二）throws 的異常處理責任

throws關鍵字的本質

throws關鍵字本身并不處理異常，它只是將異常處理的責任轉移給方法的調用者。這種機制形成了異常傳播鏈，直到異常被處理或到達調用棧頂端。

調用者的處理選擇

調用者在調用聲明了throws的方法時，有以下兩種處理方式：

1. 立即捕獲并處理異常

   這種方法適合調用者能夠處理異常的情況，可以避免異常繼續(xù)向上傳播。

   public static void main(String[] args) {
       try {
           readFileContent("test.txt");
           System.out.println("文件讀取成功");
       } catch (FileNotFoundException e) {
           System.err.println("錯誤：文件未找到 - " + e.getMessage());
           // 恢復邏輯：創(chuàng)建新文件或提示用戶
       } catch (IOException e) {
           System.err.println("IO錯誤：" + e.getMessage());
           // 其他IO異常處理
       } finally {
           System.out.println("文件操作處理完成");
       }
   }
   

2. 繼續(xù)向上傳遞異常

   當調用者也無法處理異常時，可以繼續(xù)向上傳遞異常，直到有合適的方法處理它。

   public static void processFile() throws FileNotFoundException, IOException {
       readFileContent("test.txt");
       // 其他文件處理邏輯
   }
   public static void main(String[] args) throws FileNotFoundException, IOException {
       processFile();  // 異常繼續(xù)向上傳遞
   }

異常傳播終點

當異常一直傳遞到main方法仍然未被捕獲，且main方法也使用throws聲明異常時：

1. 異常會被傳遞給JVM處理
2. JVM的默認處理方式是：
   • 打印異常堆棧跟蹤信息
   • 終止當前線程的執(zhí)行
3. 示例：

   public static void main(String[] args) throws FileNotFoundException, IOException {
       readFileContent("missing.txt");  // 如果文件不存在，程序將終止
       System.out.println("這行代碼不會被執(zhí)行");
   }
   

最佳實踐建議

1. 合理使用throws

   • 只拋出調用者能夠合理處理的異常
   • 避免過度使用throws聲明不必要的異常

2. 異常處理層級

   // 底層方法：專注于業(yè)務邏輯，拋出具體異常
   public void saveData(Data data) throws SQLException {
       // 數(shù)據(jù)庫操作
   }
   // 中層方法：整合多個操作，轉換異常類型
   public void processTransaction(Data data) throws TransactionException {
       try {
           validate(data);
           saveData(data);
           logTransaction(data);
       } catch (SQLException e) {
           throw new TransactionException("交易處理失敗", e);
       }
   }
   // 頂層方法：處理用戶交互
   public void handleUserRequest(Data data) {
       try {
           processTransaction(data);
       } catch (TransactionException e) {
           showErrorMessage(e.getMessage());
           logger.error("交易異常", e);
       }
   }

3. 異常包裝

   • 將底層異常包裝為更高層次的業(yè)務異常
   • 保留原始異常信息

   try {
       // 可能拋出SQLException的代碼
   } catch (SQLException e) {
       throw new BusinessException("數(shù)據(jù)保存失敗", e);
   }
   

四、與異常類型的關聯(lián)差異

（一）throw 與異常類型

throw 語句用于主動拋出異常對象，這個對象可以是任何合法的異常類實例，具體包括：

1. Java 內置異常類：

   • 運行時異常：如 NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等
   • 檢查型異常：如 IOException、SQLException、ClassNotFoundException 等

2. 自定義異常類：

   • 必須繼承自 Exception 類或其子類
   • 對于運行時異常，可以繼承 RuntimeException
   • 自定義異常通常需要提供至少兩個構造方法：無參構造和帶消息參數(shù)的構造

示例代碼：拋出自定義異常

// 自定義檢查型異常
class MyBusinessException extends Exception {
    // 無參構造
    public MyBusinessException() {
        super("業(yè)務異常發(fā)生");
    }
    // 帶詳細消息的構造
    public MyBusinessException(String message) {
        super(message);
    }
    // 帶原因異常的構造
    public MyBusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}
public class ExceptionDemo {
    // 方法聲明可能拋出自定義異常
    public static void validate(int value) throws MyBusinessException {
        if (value < 0) {
            // 拋出自定義異常實例
            throw new MyBusinessException("數(shù)值不能為負數(shù)");
        }
        System.out.println("驗證通過，值為：" + value);
    }
}

（二）throws 與異常類型

throws 關鍵字用于方法簽名中聲明可能拋出的異常類型，需要遵循以下規(guī)則：

1. 聲明原則：

   • 必須聲明方法內部實際可能拋出的檢查型異常
   • 可以聲明實際拋出異常的父類
   • 運行時異常（RuntimeException及其子類）不需要聲明

2. 聲明規(guī)則：

   • 可以聲明多個異常類型，用逗號分隔
   • 子類方法重寫父類方法時，throws 聲明的異常不能比父類方法聲明的異常更寬泛

示例代碼：throws 聲明

import java.io.*;
public class FileProcessor {
    // 正確：聲明實際拋出的具體異常
    public static void readConfigFile(String path) throws FileNotFoundException {
        FileInputStream fis = new FileInputStream(path);
        // 其他處理...
    }
    // 正確：聲明異常的父類
    public static void copyFile(String src, String dest) throws IOException {
        FileInputStream in = new FileInputStream(src);
        FileOutputStream out = new FileOutputStream(dest);
        // 文件復制操作...
    }
    // 錯誤示例：聲明了不可能拋出的異常（編譯時不會報錯，但邏輯錯誤）
    public static void listFiles(String dir) throws SQLException {
        File folder = new File(dir);
        for (File file : folder.listFiles()) {
            System.out.println(file.getName());
        }
    }
    // 正確：聲明多個異常
    public static void processFile(String path) 
        throws FileNotFoundException, SecurityException {
        // 可能拋出兩種異常的操作
    }
}

方法重寫時的 throws 規(guī)則

class Parent {
    public void demo() throws IOException {
        // 父類實現(xiàn)
    }
}
class Child extends Parent {
    // 正確：可以不聲明任何異常
    @Override
    public void demo() {
        // 子類實現(xiàn)
    }
    // 正確：可以聲明相同的異常
    @Override
    public void demo() throws IOException {
        // 子類實現(xiàn)
    }
    // 正確：可以聲明更具體的異常
    @Override
    public void demo() throws FileNotFoundException {
        // 子類實現(xiàn)
    }
    // 錯誤：不能聲明更寬泛的異常
    // @Override
    // public void demo() throws Exception {
    //     // 編譯錯誤
    // }
}

五、在繼承中的表現(xiàn)差異

在類的繼承關系中，子類重寫父類方法時，throw和throws的使用存在不同的限制。

（一）throw 在繼承中的表現(xiàn)

在面向對象繼承關系中，子類重寫父類方法時，關于 throw 語句的使用有以下詳細規(guī)則：

1. 相同異常：子類方法可以拋出與父類方法完全相同的異常類型。例如父類方法拋出 IOException，子類方法也可以拋出 IOException。

2. 子類異常：子類方法可以拋出父類方法所拋出異常的子類異常。這是多態(tài)性的體現(xiàn)，因為子類異常可以被父類異常引用捕獲。例如：

   • 父類拋出 IOException
   • 子類可以拋出 FileNotFoundException（IOException的子類）

3. 不拋出異常：子類方法可以選擇不拋出任何異常，即使父類方法聲明了異常。

4. 運行時異常：無論父類方法是否聲明異常，子類方法都可以自由拋出運行時異常（RuntimeException及其子類），因為運行時異常不受檢查。

實際應用場景示例：

class DatabaseReader {
    public void readData() throws SQLException {
        // 讀取數(shù)據(jù)庫
    }
}
class MySQLReader extends DatabaseReader {
    @Override
    public void readData() throws SQLException {
        // 可以拋出相同的SQLException
    }
}
class OracleReader extends DatabaseReader {
    @Override
    public void readData() {
        // 選擇不拋出任何異常
    }
}
class CustomReader extends DatabaseReader {
    @Override
    public void readData() throws BatchUpdateException {
        // 拋出SQLException的子類BatchUpdateException
    }
}

（二）throws 在繼承中的表現(xiàn)

子類重寫父類方法時，throws 聲明的異常受到更嚴格的限制：

1. 異常范圍限制：

   • 子類方法聲明的異常類型必須是父類方法聲明異常的子類或完全相同的類型
   • 不能聲明比父類方法更寬泛的異常類型
   • 例如父類聲明 IOException，子類可以聲明 FileNotFoundException，但不能聲明 Exception

2. 父類無throws聲明的情況：

   • 如果父類方法沒有使用 throws 聲明任何受檢異常
   • 子類方法也不能聲明任何受檢異常
   • 但可以拋出非受檢異常（RuntimeException及其子類）

3. 多重異常聲明：

   • 父類方法聲明多個異常時
   • 子類方法可以選擇聲明這些異常的子集或子類異常
   • 但不能添加新的受檢異常類型

更詳細的示例說明：

class Parent {
    // 情況1：父類聲明IO異常
    public void doIO() throws IOException {
        // IO操作
    }
    // 情況2：父類不聲明任何異常
    public void doNothing() {
        // 無異常操作
    }
}
class CorrectChild extends Parent {
    // 合法重寫：聲明完全相同的異常
    @Override
    public void doIO() throws IOException {
        // ...
    }
    // 合法重寫：聲明更具體的異常
    @Override
    public void doIO() throws FileNotFoundException {
        // ...
    }
    // 合法重寫：不聲明任何異常
    @Override
    public void doNothing() {
        // ...
    }
    // 合法重寫：聲明運行時異常
    @Override
    public void doNothing() throws NullPointerException {
        // ...
    }
}
class WrongChild extends Parent {
    // 非法重寫：聲明更寬泛的異常
    @Override
    public void doIO() throws Exception {  // 編譯錯誤
        // ...
    }
    // 非法重寫：聲明新的受檢異常
    @Override
    public void doNothing() throws SQLException {  // 編譯錯誤
        // ...
    }
}

這些規(guī)則確保了里氏替換原則（LSP）在異常處理中的實現(xiàn)，保證子類對象可以替換父類對象而不破壞程序的正確性。

六、使用數(shù)量的差異

（一）throw 語句的使用數(shù)量與執(zhí)行特性

在一個方法體內可以包含多個throw語句，這是完全合法的語法結構。但需要注意的是，程序執(zhí)行時只會有一個throw語句被執(zhí)行。這是因為一旦某個throw語句被執(zhí)行（即拋出異常），程序會立即中斷當前方法的執(zhí)行流程，后續(xù)的代碼（包括其他throw語句）都不會被執(zhí)行。

示例代碼分析：

public static void checkParams(String str, int num) {
    if (str == null) {
        throw new NullPointerException("字符串不能為null");  // 第一個throw
    }
    if (num < 0) {
        throw new IllegalArgumentException("數(shù)字不能為負數(shù)");  // 第二個throw
    }
}

在這個例子中，存在兩種可能的執(zhí)行路徑：

1. 當str為null時：

   • 第一個條件判斷成立
   • 執(zhí)行第一個throw語句，拋出NullPointerException
   • 方法立即終止，第二個條件判斷和throw語句都不會執(zhí)行

2. 當str不為null但num為負數(shù)時：

   • 第一個條件判斷不成立
   • 繼續(xù)執(zhí)行第二個條件判斷
   • 第二個throw語句被執(zhí)行，拋出IllegalArgumentException
   • 方法終止

3. 當兩個參數(shù)都合法時：

   • 兩個條件判斷都不成立
   • 方法正常執(zhí)行完畢，不拋出任何異常

實際應用場景： 這種多throw語句的結構常用于參數(shù)校驗或前置條件檢查，可以針對不同的錯誤情況拋出特定的異常類型，使錯誤信息更加精確。例如在Web開發(fā)中，處理API請求參數(shù)時經常會使用這種模式。

（二）throws 子句的多異常聲明

在方法聲明時，可以使用throws關鍵字來聲明該方法可能拋出的多個異常類型。這些異常類型需要用逗號分隔，形成一個異常類型列表。

示例代碼：

public static void complexOperation() 
    throws IOException, SQLException, ParseException {
    // 可能拋出多種異常的代碼
    // 比如：
    // 1. 文件讀寫操作可能拋出IOException
    // 2. 數(shù)據(jù)庫操作可能拋出SQLException
    // 3. 日期解析可能拋出ParseException
}

關鍵特性：

1. 異常類型順序：

   • 多個異常類型的聲明順序通常沒有強制要求
   • 但按照從具體到抽象的順序排列更符合規(guī)范（如先子類異常后父類異常）

2. 使用場景：

   • 當方法內部可能拋出多種不同類型的檢查異常(checked exception)時
   • 適用于方法內部調用了多個可能拋出不同異常的其他方法的情況

3. 繼承關系處理：

   • 如果聲明的多個異常有繼承關系，編譯器會去重
   • 例如同時聲明IOException和FileNotFoundException是允許的，但實際只需要聲明IOException即可，因為FileNotFoundException是其子類

4. 運行時異常：

   • 雖然RuntimeException及其子類不需要在throws中聲明
   • 但也可以選擇性地聲明，以提供給調用者更明確的提示

最佳實踐建議： 在聲明多個異常時，應該：1) 只聲明方法真正會拋出的異常；2) 避免聲明過于通用的異常類型；3) 保持異常的聲明與實際拋出的異常一致。

四、throw 和 throws 的聯(lián)系

一、同屬異常處理生態(tài)系統(tǒng)

throw和throws都是 Java 異常處理機制的關鍵構成部分。Java 的異常處理旨在捕獲、報告并合理處理程序運行時出現(xiàn)的錯誤，保障程序的穩(wěn)定性與可靠性。throw負責在程序內部主動觸發(fā)異常事件，如同發(fā)現(xiàn)問題后立即拉響警報；throws則承擔著告知外界（調用該方法的其他代碼）可能出現(xiàn)異常風險的職責，類似提前公示潛在的危險區(qū)域。二者相互配合，從異常的產生到傳播，再到最終處理，貫穿異常處理的全過程，在不同階段發(fā)揮獨特作用，共同維護程序異常處理流程的順暢。

二、針對受檢異常的協(xié)同操作

受檢異常（Checked Exception）是 Java 異常體系中必須顯式處理的一類異常，如IOException、SQLException等。在處理受檢異常時，throw和throws展現(xiàn)出緊密的協(xié)同關系。當方法內部執(zhí)行過程中檢測到受檢異常的發(fā)生條件，就需要使用throw創(chuàng)建并拋出具體的受檢異常對象，中斷當前方法執(zhí)行流程。但由于受檢異常不能被 “默默忽略”，拋出異常的方法必須明確告知調用者該風險，此時就需借助throws關鍵字在方法聲明處聲明可能拋出的受檢異常類型。例如，一個從文件讀取數(shù)據(jù)的方法readFile：

public String readFile(String filePath) throws FileNotFoundException {
FileReader reader = new FileReader(filePath);
// 讀取文件內容的邏輯，若文件不存在，會觸發(fā)FileNotFoundException
if (!new File(filePath).exists()) {
throw new FileNotFoundException("文件 " + filePath + " 不存在");
}
// 后續(xù)讀取文件操作
}

這里throw拋出FileNotFoundException，而throws聲明該異常，調用readFile方法的代碼就必須對該異常進行處理，否則會導致編譯錯誤。這種協(xié)同確保了受檢異常在整個程序中的規(guī)范處理，避免因異常未處理而引發(fā)的潛在運行時錯誤。

三、異常傳遞鏈條中的接力

在復雜的方法調用鏈中，throw和throws形成了異常傳遞的接力機制。當方法 A 內部使用throw拋出異常后，若 A 方法自身未使用try - catch塊捕獲處理該異常，就需要在方法聲明處使用throws聲明異常，將處理責任傳遞給調用 A 方法的上層方法 B。方法 B 面對傳遞過來的異常，同樣有兩種選擇：要么捕獲處理，要么繼續(xù)使用throws聲明，將異常進一步傳遞給調用 B 的方法 C，以此類推，直到有方法對異常進行捕獲處理或者異常傳遞到main方法。若main方法也不處理異常，最終異常會被 JVM 捕獲，導致程序終止并輸出異常信息。例如：

public class ExceptionChain {
public static void main(String[] args) {
try {
methodA();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void methodA() throws IOException {
methodB();
}
public static void methodB() throws IOException {
methodC();
}
public static void methodC() throws IOException {
throw new FileNotFoundException("文件未找到");
}
}

在這個例子中，methodC使用throw拋出FileNotFoundException，通過methodB和methodA的throws聲明，異常最終傳遞到main方法，由main方法捕獲處理。throw和throws在這個鏈條中，一個負責 “拋出異常啟動傳遞”，一個負責 “傳遞異常接力棒”，確保異常在整個調用鏈中有序傳播，便于在合適的層級進行處理。

四、與自定義異常的結合運用

自定義異常是開發(fā)者根據(jù)業(yè)務需求創(chuàng)建的異常類型，用于更精準地表示程序中出現(xiàn)的特定錯誤情況。throw和throws在自定義異常的使用中也相互配合。首先，創(chuàng)建自定義異常類（通常繼承自Exception或其子類），然后在方法內部，當滿足特定業(yè)務異常條件時，使用throw拋出該自定義異常對象。同時，為了讓調用者知曉該方法可能拋出自定義異常，需在方法聲明處借助throws聲明自定義異常類型。例如，定義一個業(yè)務邏輯中賬戶余額不足的自定義異常：

class InsufficientBalanceException extends Exception {
public InsufficientBalanceException(String message) {
super(message);
}
}
public class BankAccount {
private double balance;
public BankAccount(double initialBalance) {
this.balance = initialBalance;
}
public void withdraw(double amount) throws InsufficientBalanceException {
if (amount > balance) {
throw new InsufficientBalanceException("賬戶余額不足，當前余額為 " + balance + "，取款金額為 " + amount);
}
balance -= amount;
}
}

在withdraw方法中，throw拋出InsufficientBalanceException自定義異常，throws聲明該異常，調用withdraw方法的代碼就需要針對該自定義異常進行處理，使業(yè)務異常在程序中得到妥善的表達與處理。

五、異常類型匹配與多態(tài)性體現(xiàn)

在 Java 的異常處理體系中，異常類型之間存在繼承關系，這使得throw和throws在處理異常時體現(xiàn)出多態(tài)性特點。當使用throw拋出一個具體異常對象時，它可以是某個異常類的實例，也可以是該異常類子類的實例。而throws聲明的異常類型可以是實際拋出異常的父類。例如，方法內部可能拋出FileNotFoundException（它是IOException的子類），那么在方法聲明處既可以使用throws FileNotFoundException，也可以使用throws IOException聲明。這種基于異常類型繼承的多態(tài)性，讓throw和throws在異常處理中更加靈活，調用者可以根據(jù)更寬泛的異常類型進行統(tǒng)一處理，同時又不失異常的具體性。例如：

public void readData() throws IOException {
try {
// 讀取數(shù)據(jù)操作，可能拋出FileNotFoundException
FileReader reader = new FileReader("data.txt");
} catch (FileNotFoundException e) {
// 捕獲具體異常
throw e; // 重新拋出異常，可由調用者根據(jù)聲明的IOException統(tǒng)一處理
}
}

這里readData方法聲明拋出IOException，內部實際拋出FileNotFoundException，通過throw和throws對異常類型的匹配與多態(tài)運用，實現(xiàn)了異常處理的靈活性與層次性。

綜上，throw和throws在 Java 異常處理中相互依存、協(xié)同工作，從異常的拋出、傳遞到處理，在各個環(huán)節(jié)緊密配合，為開發(fā)者提供了強大且靈活的異常處理工具，助力構建健壯、可靠的 Java 程序。

五、注意事項

1.使用 throw 時的注意事項

throw后面必須跟一個具體的異常對象實例，不能直接使用異常類型。例如：

// 錯誤寫法
throw IllegalArgumentException;
// 正確寫法
throw new IllegalArgumentException("參數(shù)不能為null");

拋出異常后會立即中斷當前方法的執(zhí)行流程，控制權會轉移到最近的異常處理塊。因此，在throw語句后面放置的任何代碼都不會被執(zhí)行：

public void processValue(int value) {
    if (value < 0) {
        throw new IllegalArgumentException("數(shù)值不能為負數(shù)");
        // 下面這行代碼永遠不會執(zhí)行
        System.out.println("繼續(xù)處理..."); 
    }
    // 其他處理邏輯
}

對于checked異常的處理要求：

• 必須在方法內部使用try-catch塊捕獲處理
• 或者在方法簽名中使用throws聲明拋出 例如：

// 方式1：捕獲處理
public void readFile() {
    try {
        // 可能拋出IOException的代碼
    } catch (IOException e) {
        // 處理異常
    }
}
// 方式2：聲明拋出
public void readFile() throws IOException {
    // 可能拋出IOException的代碼
}

2.用 throws 時的注意事項

throws聲明的異常類型必須與方法內部實際可能拋出的異常匹配：

// 錯誤：聲明了不相關的異常
public void process() throws SQLException {
    // 這個方法實際上不會拋出SQLException
    throw new IOException(); // 編譯錯誤
}
// 正確
public void process() throws IOException {
    throw new IOException();
}

調用聲明了異常的方法時的處理方式：

// 情況1：捕獲處理
public void caller() {
    try {
        methodThrowsException();
    } catch (IOException e) {
        // 處理異常
    }
}
// 情況2：繼續(xù)聲明
public void caller() throws IOException {
    methodThrowsException();
}

方法重寫時的異常聲明規(guī)則：

class Parent {
    public void demo() throws IOException {
        // 父類方法
    }
}
class Child extends Parent {
    // 正確：不拋出異常
    @Override
    public void demo() {
        // 子類實現(xiàn)
    }
    // 正確：拋出更具體的異常
    @Override
    public void demo() throws FileNotFoundException {
        // 子類實現(xiàn)
    }
    // 錯誤：拋出更寬泛的異常
    @Override
    public void demo() throws Exception {
        // 編譯錯誤
    }
}

到此這篇關于Java 中 throw 和 throws 的全面解析的文章就介紹到這了,更多相關Java 中 throw 和 throws內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論