跳到主要内容

Java try...catch语句

提示
  1. 基本用法：try...catch 块在Java中用于处理异常，防止程序异常终止。try 块包含可能产生异常的代码，而 catch 块包含处理异常的代码。
  2. 使用finally块：finally 块与 try 块一起使用，无论是否发生异常，finally 块中的代码都会执行，通常用于执行重要的清理工作。
  3. 多个catch块和try-with-resources：每个 try 块可以有多个 catch 块来处理不同类型的异常，从Java SE 7开始，可以使用 try-with-resources 语句自动管理资源，确保在语句结束时关闭所有资源。

在 Java 中，try...catch 块用于处理异常，并防止程序异常终止。

这是 Java 中 try...catch 块的语法。

try{
  // 代码
}
catch(exception) {
  // 代码
}

try 块包括可能生成异常的代码。

catch 块包括当 try 块内发生异常时执行的代码。

示例：Java try...catch 块​

class Main {
  public static void main(String[] args) {

    try {
      int divideByZero = 5 / 0;
      System.out.println("try 块中的其余代码");
    }

    catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }
  }
}

输出

ArithmeticException => / by zero

在上面的示例中，请注意这一行，

int divideByZero = 5 / 0;

这里，我们试图将一个数字除以 零。在这种情况下，会发生异常。因此，我们将这段代码放在 try 块中。

当程序遇到这段代码时，会发生 ArithmeticException。这个异常被 catch 块捕获，并执行 catch 块内的代码。

只有在 try 块内存在异常时，catch 块才会执行。

注意：在 Java 中，我们可以在没有 catch 块的情况下使用 try 块。然而，我们不能在没有 try 块的情况下使用 catch 块。

Java try...finally 块​

我们也可以将 try 块与 finally 块一起使用。

在这种情况下，无论 try 块内是否有异常，finally 块都会被执行。

示例：Java try...finally 块​

class Main {
  public static void main(String[] args) {
    try {
      int divideByZero = 5 / 0;
    }

    finally {
      System.out.println("Finally 块总是被执行");
    }
  }
}

输出

Finally 块总是被执行
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at Main.main(Main.java:4)

在上述示例中，我们使用了 try 块和 finally 块。我们可以看到 try 块内的代码引起了一个异常。

然而，无论异常如何，finally 块内的代码都会被执行。

Java try...catch...finally 块​

在 Java 中，我们也可以在 try...catch 块之后使用 finally 块。例如，

import java.io.*;

class ListOfNumbers {

// 创建一个整数数组
private int[] list = {5, 6, 8, 9, 2};

// 方法用于将数组中的数据写入文件
public void writeList() {
PrintWriter out = null;

    try {
      System.out.println("进入 try 语句块");

      // 创建一个新文件 OutputFile.txt
      out = new PrintWriter(new FileWriter("OutputFile.txt"));

      // 将 list 数组的值写入 Output.txt
      for (int i = 0; i < 7; i++) {
        out.println("索引 " + i + " 的值 = " + list[i]);
      }
    }

    catch (Exception e) {
      System.out.println("异常 => " + e.getMessage());
    }

    finally {
      // 检查 PrintWriter 是否已被打开
      if (out != null) {
        System.out.println("关闭 PrintWriter");
        // 关闭 PrintWriter
        out.close();
      }

      else {
        System.out.println("PrintWriter 未打开");
      }
    }

}
}

class Main {
public static void main(String[] args) {
ListOfNumbers list = new ListOfNumbers();
list.writeList();
}
}

输出

进入 try 语句块
异常 => 索引 5 超出长度 5 的界限
关闭 PrintWriter

在上面的示例中，我们创建了一个名为 list 的数组和一个名为 output.txt 的文件。在这里，我们尝试从数组中读取数据并存储到文件中。

注意代码，

for (int i = 0; i < 7; i++) {
  out.println("索引 " + i + " 的值 = " + list[i]);
}

这里，数组的大小是 5，数组的最后一个元素是 list[4]。但是，我们尝试访问 list[5] 和 list[6]。

因此，代码产生了一个异常，该异常被 catch 块捕获。

由于 finally 块总是被执行，我们在 finally 块中包含了关闭 PrintWriter 的代码。

使用 finally 块来包含重要的清理代码，如关闭文件或连接，是一个好习惯。

注意：在某些情况下，finally 块不会执行：

  • 使用 System.exit() 方法
  • finally 块中发生异常
  • 线程终止

多个 Catch 块​

对于每个 try 块，可以有零个或多个 catch 块。多个 catch 块允许我们以不同的方式处理每个异常。

每个 catch 块的参数类型表示它可以处理的异常类型。例如，

class ListOfNumbers {
  public int[] arr = new int[10];

  public void writeList() {

    try {
      arr[10] = 11;
    }

    catch (NumberFormatException e1) {
      System.out.println("NumberFormatException => " + e1.getMessage());
    }

    catch (IndexOutOfBoundsException e2) {
      System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
    }

  }
}

class Main {
  public static void main(String[] args) {
    ListOfNumbers list = new ListOfNumbers();
    list.writeList();
  }
}
```**输出**

```java
IndexOutOfBoundsException => 索引 10 超出长度 10 的界限

在这个示例中，我们创建了一个大小为 10 的整数数组 arr。

由于数组索引从 0 开始，数组的最后一个元素位于 arr[9]。注意以下语句，

arr[10] = 11;

这里，我们试图将值赋给索引 10。因此，发生了 IndexOutOfBoundsException（索引越界异常）。

当 try 块中发生异常时，

  • 异常被抛给第一个 catch 块。第一个 catch 块不处理 IndexOutOfBoundsException，所以它被传递到下一个 catch 块。
  • 上例中的第二个 catch 块是适当的异常处理器，因为它处理 IndexOutOfBoundsException。因此，它被执行。

捕获多个异常​

从 Java SE 7 及以后的版本开始，我们现在可以用一个 catch 块捕获多种类型的异常。

这减少了代码重复，并提高了代码的简洁性和效率。

catch 块可以处理的每种异常类型都使用竖线 | 分隔。

其语法为：

try {
  // 代码
} catch (ExceptionType1 | ExceptionType2 ex) {
  // catch 块
}

要了解更多，请访问 Java 捕获多个异常。

Java try-with-resources 语句​

try-with-resources 语句是带有一个或多个资源声明的 try 语句。

其语法为：

try (资源声明) {
  // 资源的使用
} catch (ExceptionType e1) {
  // catch 块
}

资源是程序结束时需要关闭的对象。它必须在 try 语句中声明和初始化。

让我们看一个例子。

try (PrintWriter out = new PrintWriter(new FileWriter("OutputFile.txt"))) {
  // 资源的使用
}

try-with-resources 语句也被称为 自动资源管理。该语句在语句结束时自动关闭所有资源。

要了解更多，请访问 Java try-with-resources 语句。

最后于 更新