本節(jié)描述如何使用三個(gè)異常處理程序組件 — try、catch和finally塊 — 來(lái)編寫異常處理程序，然后，解釋了Java SE 7中引入的try-with-resources語(yǔ)句，try-with-resources語(yǔ)句特別適用于使用Closeable資源的情況，例如流。

本節(jié)的最后一部分將介紹一個(gè)示例，并分析各種場(chǎng)景中發(fā)生的情況。

以下示例定義并實(shí)現(xiàn)名為ListOfNumbers的類，構(gòu)造時(shí)，ListOfNumbers創(chuàng)建一個(gè)ArrayList，其中包含10個(gè)具有順序值0到9的整數(shù)元素，ListOfNumbers類還定義了一個(gè)名為writeList的方法，該方法將數(shù)字列表寫入名為OutFile.txt的文本文件中，此示例使用java.io中定義的輸出類，這些類在基礎(chǔ)I/O中介紹。

// Note: This class will not compile yet.
import java.io.*;
import java.util.List;
import java.util.ArrayList;

public class ListOfNumbers {

    private List list;
    private static final int SIZE = 10;

    public ListOfNumbers () {
        list = new ArrayList(SIZE);
        for (int i = 0; i < SIZE; i++) {
            list.add(new Integer(i));
        }
    }

    public void writeList() {
    // The FileWriter constructor throws IOException, which must be caught.
        PrintWriter out = new PrintWriter(new FileWriter("OutFile.txt"));

        for (int i = 0; i < SIZE; i++) {
            // The get(int) method throws IndexOutOfBoundsException, which must be caught.
            out.println("Value at: " + i + " = " + list.get(i));
        }
        out.close();
    }
}

FileWriter構(gòu)造函數(shù)初始化文件上的輸出流，如果無(wú)法打開該文件，則構(gòu)造函數(shù)將拋出IOException。對(duì)ArrayList類的get方法的調(diào)用，如果其參數(shù)的值太小（小于0）或太大（大于ArrayList當(dāng)前包含的元素?cái)?shù)），則拋出IndexOutOfBoundsException。

如果你嘗試編譯ListOfNumbers類，編譯器將輸出有關(guān)FileWriter構(gòu)造函數(shù)拋出的異常的錯(cuò)誤消息，但是，它不會(huì)顯示有關(guān)get拋出的異常的錯(cuò)誤消息，原因是構(gòu)造函數(shù)拋出的異常IOException是一個(gè)經(jīng)過(guò)檢查的異常，而get方法拋出的異常（IndexOutOfBoundsException）是一個(gè)未經(jīng)檢查的異常。

現(xiàn)在你已熟悉ListOfNumbers類以及可以在其中拋出異常的位置，你已準(zhǔn)備好編寫異常處理程序來(lái)捕獲和處理這些異常。

構(gòu)造異常處理程序的第一步是使用try塊將可能引發(fā)異常的代碼括起來(lái)，通常，try塊如下所示：

try {
    code
}
catch and finally blocks . . .

標(biāo)記為code的示例段中包含一個(gè)或多個(gè)可能引發(fā)異常的合法代碼行（catch和finally塊將在接下來(lái)的兩個(gè)小節(jié)中解釋）。

要從ListOfNumbers類構(gòu)造writeList方法的異常處理程序，請(qǐng)將writeList方法的異常拋出語(yǔ)句包含在try塊中，有不止一種方法可以做到這一點(diǎn)，你可以將可能引發(fā)異常的每行代碼放在其自己的try塊中，并為每個(gè)代碼提供多帶帶的異常處理程序。或者，你可以將所有writeList代碼放在一個(gè)try塊中，并將多個(gè)處理程序與它相關(guān)聯(lián)，以下列表對(duì)整個(gè)方法使用一個(gè)try塊，因?yàn)樗懻摰拇a非常短。

private List list;
private static final int SIZE = 10;

public void writeList() {
    PrintWriter out = null;
    try {
        System.out.println("Entered try statement");
        out = new PrintWriter(new FileWriter("OutFile.txt"));
        for (int i = 0; i < SIZE; i++) {
            out.println("Value at: " + i + " = " + list.get(i));
        }
    }
    catch and finally blocks  . . .
}

如果try塊中發(fā)生異常，則該異常由與之關(guān)聯(lián)的異常處理程序處理，要將異常處理程序與try塊關(guān)聯(lián)，必須在其后面放置一個(gè)catch塊。

通過(guò)在try塊之后直接提供一個(gè)或多個(gè)catch塊，可以將異常處理程序與try塊關(guān)聯(lián)，try塊的末尾和第一個(gè)catch塊的開頭之間不能有代碼。

try {

} catch (ExceptionType name) {

} catch (ExceptionType name) {

}

每個(gè)catch塊都是一個(gè)異常處理程序，它處理由其參數(shù)表示的異常類型，參數(shù)類型ExceptionType聲明了處理程序可以處理的異常類型，并且必須是從Throwable類繼承的類的名稱，處理程序可以使用name引用異常。

catch塊包含在調(diào)用異常處理程序時(shí)執(zhí)行的代碼，當(dāng)處理程序是調(diào)用堆棧中的第一個(gè)ExceptionType與拋出的異常類型匹配時(shí)，運(yùn)行時(shí)系統(tǒng)調(diào)用此異常處理程序，如果拋出的對(duì)象可以合法地分配給異常處理程序的參數(shù)，則系統(tǒng)認(rèn)為它是匹配的。

以下是writeList方法的兩個(gè)異常處理程序：

try {

} catch (IndexOutOfBoundsException e) {
    System.err.println("IndexOutOfBoundsException: " + e.getMessage());
} catch (IOException e) {
    System.err.println("Caught IOException: " + e.getMessage());
}

異常處理程序不僅可以打印錯(cuò)誤消息或停止程序，它們可以執(zhí)行錯(cuò)誤恢復(fù)、提示用戶做出決定，或使用鏈?zhǔn)疆惓㈠e(cuò)誤傳播到更高級(jí)別的處理程序，如“鏈?zhǔn)疆惓！辈糠炙觥?/p> 使用一個(gè)異常處理程序捕獲多種類型的異常

在Java SE 7及更高版本中，單個(gè)catch塊可以處理多種類型的異常，此功能可以減少代碼重復(fù)并減少捕獲過(guò)于寬泛的異常的誘惑。

在catch子句中，指定塊可以處理的異常類型，并使用豎線（|）分隔每個(gè)異常類型：

catch (IOException|SQLException ex) {
    logger.log(ex);
    throw ex;
}

注意：如果catch塊處理多個(gè)異常類型，則catch參數(shù)隱式為final，在此示例中，catch參數(shù)ex是final，因此你無(wú)法在catch塊中為其分配任何值。

當(dāng)try塊退出時(shí)，finally塊總是執(zhí)行，這確保即使發(fā)生意外異常也會(huì)執(zhí)行finally塊，但finally不僅僅是異常處理有用 — 它允許程序員避免因return、continue或break而意外繞過(guò)清理代碼，將清理代碼放在finally塊中始終是一種很好的做法，即使沒有預(yù)期的異常情況也是如此。

注意：如果在執(zhí)行try或catch代碼時(shí)JVM退出，則finally塊可能無(wú)法執(zhí)行，同樣，如果執(zhí)行try或catch代碼的線程被中斷或終止，則即使應(yīng)用程序作為一個(gè)整體繼續(xù)，finally塊也可能無(wú)法執(zhí)行。

你在此處使用的writeList方法的try塊打開了PrintWriter，程序應(yīng)該在退出writeList方法之前關(guān)閉該流，這帶來(lái)了一個(gè)有點(diǎn)復(fù)雜的問題，因?yàn)?b>writeList的try塊可以以三種方式之一退出。

new FileWriter語(yǔ)句失敗并拋出IOException。

list.get(i)語(yǔ)句失敗并拋出IndexOutOfBoundsException。

一切都成功，try塊正常退出。

無(wú)論try塊中發(fā)生了什么，運(yùn)行時(shí)系統(tǒng)總是執(zhí)行finally塊中的語(yǔ)句，所以這是進(jìn)行清理的最佳地點(diǎn)。

下面的writeList方法的finally塊清理然后關(guān)閉PrintWriter。

finally {
    if (out != null) { 
        System.out.println("Closing PrintWriter");
        out.close(); 
    } else { 
        System.out.println("PrintWriter not open");
    } 
}

重要提示：finally塊是防止資源泄漏的關(guān)鍵工具，關(guān)閉文件或以其他方式恢復(fù)資源時(shí)，將代碼放在finally塊中以確保始終恢復(fù)資源。
請(qǐng)考慮在這些情況下使用try-with-resources語(yǔ)句，這會(huì)在不再需要時(shí)自動(dòng)釋放系統(tǒng)資源，try-with-resources語(yǔ)句部分提供了更多信息。

try-with-resources語(yǔ)句是一個(gè)聲明一個(gè)或多個(gè)資源的try語(yǔ)句，資源是在程序完成后必須關(guān)閉的對(duì)象，try-with-resources語(yǔ)句確保在語(yǔ)句結(jié)束時(shí)關(guān)閉每個(gè)資源，實(shí)現(xiàn)java.lang.AutoCloseable的任何對(duì)象（包括實(shí)現(xiàn)java.io.Closeable的所有對(duì)象）都可以用作資源。

以下示例從文件中讀取第一行，它使用BufferedReader實(shí)例從文件中讀取數(shù)據(jù)，BufferedReader是一個(gè)在程序完成后必須關(guān)閉的資源：

static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br =
                   new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

在此示例中，try-with-resources語(yǔ)句中聲明的資源是BufferedReader，聲明語(yǔ)句出現(xiàn)在try關(guān)鍵字后面的括號(hào)內(nèi)，Java SE 7及更高版本中的BufferedReader類實(shí)現(xiàn)了java.lang.AutoCloseable接口，因?yàn)?b>BufferedReader實(shí)例是在try-with-resource語(yǔ)句中聲明的，所以無(wú)論try語(yǔ)句是正常完成還是突然完成（由于BufferedReader.readLine方法拋出IOException），它都將被關(guān)閉。

在Java SE 7之前，你可以使用finally塊來(lái)確保關(guān)閉資源，無(wú)論try語(yǔ)句是正常還是突然完成，以下示例使用finally塊而不是try-with-resources語(yǔ)句：

static String readFirstLineFromFileWithFinallyBlock(String path)
                                                     throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(path));
    try {
        return br.readLine();
    } finally {
        if (br != null) br.close();
    }
}

但是，在此示例中，如果方法readLine和close都拋出異常，則方法readFirstLineFromFileWithFinallyBlock拋出finally塊拋出的異常，從try塊拋出的異常被抑制。相反，在示例readFirstLineFromFile中，如果從try塊和try-with-resources語(yǔ)句拋出異常，則readFirstLineFromFile方法拋出try塊拋出的異常，從try-with-resources塊拋出的異常被抑制，在Java SE 7及更高版本中，你可以檢索已抑制的異常，有關(guān)詳細(xì)信息，請(qǐng)參閱“抑制的異常”部分。

你可以在try-with-resources語(yǔ)句中聲明一個(gè)或多個(gè)資源，以下示例檢索zip文件zipFileName中打包的文件的名稱，并創(chuàng)建包含這些文件名稱的文本文件：

public static void writeToFileZipFileContents(String zipFileName,
                                           String outputFileName)
                                           throws java.io.IOException {

    java.nio.charset.Charset charset =
         java.nio.charset.StandardCharsets.US_ASCII;
    java.nio.file.Path outputFilePath =
         java.nio.file.Paths.get(outputFileName);

    // Open zip file and create output file with 
    // try-with-resources statement

    try (
        java.util.zip.ZipFile zf =
             new java.util.zip.ZipFile(zipFileName);
        java.io.BufferedWriter writer = 
            java.nio.file.Files.newBufferedWriter(outputFilePath, charset)
    ) {
        // Enumerate each entry
        for (java.util.Enumeration entries =
                                zf.entries(); entries.hasMoreElements();) {
            // Get the entry name and write it to the output file
            String newLine = System.getProperty("line.separator");
            String zipEntryName =
                 ((java.util.zip.ZipEntry)entries.nextElement()).getName() +
                 newLine;
            writer.write(zipEntryName, 0, zipEntryName.length());
        }
    }
}

在此示例中，try-with-resources語(yǔ)句包含兩個(gè)以分號(hào)分隔的聲明：ZipFile和BufferedWriter，當(dāng)直接跟隨它的代碼塊正常或由于異常而終止時(shí)，將按此順序自動(dòng)調(diào)用BufferedWriter和ZipFile對(duì)象的close方法，請(qǐng)注意，資源的close方法按其創(chuàng)建的相反順序調(diào)用。

以下示例使用try-with-resources語(yǔ)句自動(dòng)關(guān)閉java.sql.Statement對(duì)象：

public static void viewTable(Connection con) throws SQLException {

    String query = "select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES";

    try (Statement stmt = con.createStatement()) {
        ResultSet rs = stmt.executeQuery(query);

        while (rs.next()) {
            String coffeeName = rs.getString("COF_NAME");
            int supplierID = rs.getInt("SUP_ID");
            float price = rs.getFloat("PRICE");
            int sales = rs.getInt("SALES");
            int total = rs.getInt("TOTAL");

            System.out.println(coffeeName + ", " + supplierID + ", " + 
                               price + ", " + sales + ", " + total);
        }
    } catch (SQLException e) {
        JDBCTutorialUtilities.printSQLException(e);
    }
}

此示例中使用的資源java.sql.Statement是JDBC 4.1及更高版本API的一部分。

注意：try-with-resources語(yǔ)句可以像普通的try語(yǔ)句一樣有catch和finally塊，在try-with-resources語(yǔ)句中，在聲明的資源關(guān)閉后運(yùn)行任何catch或finally塊。

可以從與try-with-resources語(yǔ)句關(guān)聯(lián)的代碼塊中拋出異常，在示例writeToFileZipFileContents中，可以從try塊拋出異常，當(dāng)try-with-resources語(yǔ)句嘗試關(guān)閉ZipFile和BufferedWriter對(duì)象時(shí)，最多可以拋出兩個(gè)異常。如果從try塊拋出異常，并且從try-with-resources語(yǔ)句中拋出一個(gè)或多個(gè)異常，則會(huì)抑制從try-with-resources語(yǔ)句拋出的那些異常，并且塊拋出的異常是writeToFileZipFileContents方法拋出的異常，你可以通過(guò)從try塊拋出的異常中調(diào)用Throwable.getSuppressed方法來(lái)檢索這些抑制的異常。

請(qǐng)參閱AutoCloseable和Closeable接口的Javadoc，以獲取實(shí)現(xiàn)這些接口之一的類列表，Closeable接口擴(kuò)展了AutoCloseable接口。Closeable接口的close方法拋出IOException類型的異常，而AutoCloseable接口的close方法拋出異常類型Exception，因此，AutoCloseable接口的子類可以覆蓋close方法的這種行為，以拋出專門的異常，例如IOException，或者根本沒有異常。

前面的部分描述了如何為ListOfNumbers類中的writeList方法構(gòu)造try、catch和finally代碼塊，現(xiàn)在，讓我們來(lái)看看代碼并調(diào)查會(huì)發(fā)生什么。

將所有組件放在一起時(shí)，writeList方法如下所示。

public void writeList() {
    PrintWriter out = null;

    try {
        System.out.println("Entering" + " try statement");

        out = new PrintWriter(new FileWriter("OutFile.txt"));
        for (int i = 0; i < SIZE; i++) {
            out.println("Value at: " + i + " = " + list.get(i));
        }
    } catch (IndexOutOfBoundsException e) {
        System.err.println("Caught IndexOutOfBoundsException: "
                           +  e.getMessage());
                                 
    } catch (IOException e) {
        System.err.println("Caught IOException: " +  e.getMessage());
                                 
    } finally {
        if (out != null) {
            System.out.println("Closing PrintWriter");
            out.close();
        } 
        else {
            System.out.println("PrintWriter not open");
        }
    }
}

如前所述，此方法的try塊有三種不同的退出可能性，這是其中兩個(gè)。

try語(yǔ)句中的代碼失敗并引發(fā)異常，這可能是由new FileWriter語(yǔ)句引起的IOException或由for循環(huán)中的錯(cuò)誤索引值引起的IndexOutOfBoundsException。

一切都成功，try語(yǔ)句正常退出。

創(chuàng)建FileWriter的語(yǔ)句可能由于多種原因而失敗，例如，如果程序無(wú)法創(chuàng)建或?qū)懭胫甘镜奈募瑒tFileWriter的構(gòu)造函數(shù)將拋出IOException。

當(dāng)FileWriter拋出IOException時(shí)，運(yùn)行時(shí)系統(tǒng)立即停止執(zhí)行try塊，正在執(zhí)行的方法調(diào)用未完成，然后，運(yùn)行時(shí)系統(tǒng)開始在方法調(diào)用堆棧的頂部搜索適當(dāng)?shù)漠惓Ｌ幚沓绦颉Ｔ诖耸纠校l(fā)生IOException時(shí)，FileWriter構(gòu)造函數(shù)位于調(diào)用堆棧的頂部，但是，FileWriter構(gòu)造函數(shù)沒有適當(dāng)?shù)漠惓Ｌ幚沓绦颍虼诉\(yùn)行時(shí)系統(tǒng)在方法調(diào)用堆棧中檢查下一個(gè)方法 — writeList方法，writeList方法有兩個(gè)異常處理程序：一個(gè)用于IOException，另一個(gè)用于IndexOutOfBoundsException。

運(yùn)行時(shí)系統(tǒng)按照它們?cè)?b>try語(yǔ)句之后出現(xiàn)的順序檢查writeList的處理程序，第一個(gè)異常處理程序的參數(shù)是IndexOutOfBoundsException，這與拋出的異常類型不匹配，因此運(yùn)行時(shí)系統(tǒng)會(huì)檢查下一個(gè)異常處理程序 — IOException，這與拋出的異常類型相匹配，因此運(yùn)行時(shí)系統(tǒng)結(jié)束搜索適當(dāng)?shù)漠惓Ｌ幚沓绦颍热贿\(yùn)行時(shí)已找到適當(dāng)?shù)奶幚沓绦颍敲磮?zhí)行該catch塊中的代碼。

異常處理程序執(zhí)行后，運(yùn)行時(shí)系統(tǒng)將控制權(quán)傳遞給finally塊，無(wú)論上面捕獲的異常如何，finally塊中的代碼都會(huì)執(zhí)行，在這種情況下，FileWriter從未打開過(guò)，不需要關(guān)閉，在finally塊完成執(zhí)行后，程序繼續(xù)執(zhí)行finally塊之后的第一個(gè)語(yǔ)句。

這是拋出IOException時(shí)出現(xiàn)的ListOfNumbers程序的完整輸出。

Entering try statement
Caught IOException: OutFile.txt
PrintWriter not open

以下清單中的后加*號(hào)的代碼顯示了在此方案中執(zhí)行的語(yǔ)句：

public void writeList() {
   PrintWriter out = null; //******

    try {
        System.out.println("Entering try statement"); //*******
        out = new PrintWriter(new FileWriter("OutFile.txt")); //******
        for (int i = 0; i < SIZE; i++)
            out.println("Value at: " + i + " = " + list.get(i));
                               
    } catch (IndexOutOfBoundsException e) {
        System.err.println("Caught IndexOutOfBoundsException: "
                           + e.getMessage());
                                 
    } catch (IOException e) {
        System.err.println("Caught IOException: " + e.getMessage()); //*****
    } finally {
        if (out != null) { //*****
            System.out.println("Closing PrintWriter");
            out.close();
        } 
        else {
            System.out.println("PrintWriter not open"); /******
        }
    }
}

在這種情況下，try塊范圍內(nèi)的所有語(yǔ)句都成功執(zhí)行，并且不會(huì)拋出異常，執(zhí)行在try塊的末尾結(jié)束，運(yùn)行時(shí)系統(tǒng)將控制傳遞給finally塊，因?yàn)橐磺卸汲晒α耍援?dāng)控制到達(dá)finally塊時(shí)，PrintWriter會(huì)打開，這會(huì)關(guān)閉PrintWriter，同樣，在finally塊完成執(zhí)行之后，程序繼續(xù)執(zhí)行finally塊之后的第一個(gè)語(yǔ)句。

當(dāng)沒有拋出異常時(shí)，這是ListOfNumbers程序的輸出。

Entering try statement
Closing PrintWriter

以下示例中的加*號(hào)的代碼顯示了在此方案中執(zhí)行的語(yǔ)句。

public void writeList() {
    PrintWriter out = null; //*****
    try {
        System.out.println("Entering try statement"); //******
        out = new PrintWriter(new FileWriter("OutFile.txt")); //******
        for (int i = 0; i < SIZE; i++) //******
            out.println("Value at: " + i + " = " + list.get(i)); //******
                  
    } catch (IndexOutOfBoundsException e) {
        System.err.println("Caught IndexOutOfBoundsException: "
                           + e.getMessage());

    } catch (IOException e) {
        System.err.println("Caught IOException: " + e.getMessage());
                                 
    } finally {
        if (out != null) { //******
            System.out.println("Closing PrintWriter"); //******
            out.close(); //*******
        } 
        else {
            System.out.println("PrintWriter not open");
        }
    }
}