Java SE 7 中引入的异常处理中的版本增强

在本文中，讨论了 Oracle 在1.7 版中所做的增强以及它的实现。

作为 1.7 版本增强的一部分，在异常处理中，Oracle 引入了以下两个概念：

1. 尝试使用资源。
2. 多个 catch 块。

用资源试试

在 1.6 版本之前，强烈建议编写 finally 块来关闭作为 try 块的一部分打开的所有资源。

例如：

// Java program to illustrate cleaning of
// resources before Java 7
  
import java.io.*;
import java.util.*;
  
class Resource {
    public static void main(String args[])
    {
        BufferedReader br = null;
        String str = " ";
  
        System.out.println(
            "Enter the file path");
        br
            = new BufferedReader(
                new InputStreamReader(
                    System.in));
  
        try {
  
            str = br.readLine();
  
            String s;
  
            // file resource
            br
                = new BufferedReader(
                    new FileReader(str));
  
            while ((s = br.readLine()) != null) {
                // print all the lines
                // in the text file
                System.out.println(s);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
  
        // This part was compulsory before Java 7
        // but with the introduction of
        // try with resource in Java 7
        // this part is optional now.
        finally {
            try {
                if (br != null)
  
                    // closing the resource
                    // in 'finally' block
                    br.close();
            }
            catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

输出：

hello
java

使用资源尝试的优势：

1. try with resources的主要优点是，作为 try 块的一部分打开的资源将在控制正常或异常到达 try 块的末尾时自动关闭。因此，我们不需要明确地关闭它。因此，编程的复杂性将降低。
2. 我们可以声明任意数量的资源，但所有这些资源都应该用分号（;）分隔

   try(R1;R2;R3)
   {
   - - - - - - -
   - - - - - - -
   }
   

3. 所有资源都应该是 AutoCloseable 资源。当且仅当对应的类时，才说资源是可自动关闭的
   直接或间接实现Java.lang.AutoCloseable 接口。
   比如所有数据库相关、网络相关、文件IO相关的资源都已经实现了AutoCloseable接口。
4. 所有资源引用变量都是隐式最终的，因此我们不能在 try 块中执行重新分配。例如，在下面的代码中，我们重新分配了br的值，我们得到了编译时错误。

   try (BufferedReader br = new BufferedReader(new FileReader("abc.txt"))) {
       br = new BufferedReader(new FileReader("abc.txt"));
   }
   

5. 在 1.6 版本之前，try 后面应该跟 catch 或 finally，但是 1.7 版本我们只能对没有 catch 或 finally 语句的资源进行尝试。

   try(R)
   {  //valid
   }
   

下面是增强的 try-catch 块的实现：

// Try opening a file
try (bufferedReader br = new BufferedReader(new FileReader("abc.txt"))) {
}
  
// Catch an exception
catch (IOException e) { // handling code }
  
// After the execution of try and catch is completed
// the file is closed automatically by Java

多个catch块：

直到 1.6 版本，如果我们希望为同一个 try 块处理多个异常，我们必须在多个 catch 语句中定义所有异常。

例如：

// For this try block
try {
    -------- - -------- -
}
  
// Catching Arithmetic Exception
catch (ArithmeticException e) {
    e.printStackTrace();
}
  
// Catching Nullpointer Exception
catch (e) {
    e.printStackTrace();
}
  
// Catching Class Cast Exception
catch (ClassCastException e) {
    System.out.println(e.getMessage());
}
  
// Catching IOException
catch (IOException e) {
    System.out.println(e.getMessage());
}

为了克服这个问题，在 1.7 版本中引入了“Multi catch block”的概念。因此，所有的异常都可以用一条catch 语句来处理。

下面是multi-catch语句的实现：

try {
    ------ - ------ -
}
catch (ArithmeticException | NullpointerException
       | ClassCastException | IOException e) {
    System.out.println(e.getMessage());
}

注意：在多捕获块中，异常类型之间不应有任何关系（子与父或父与子或相同类型。