跳到主要内容

Java异常处理

提示
  1. try...catch块：在Java中，try...catch块用于处理异常，其中try块包含可能引发异常的代码，而catch块捕获并处理这些异常。
  2. finally块：finally块是可选的，无论是否发生异常，它总是在try...catch块之后执行，常用于执行清理操作，如关闭文件或连接。
  3. throw和throws关键字：throw关键字用于显式地抛出单个异常，而throws关键字声明一个方法可能抛出的异常类型，用于方法声明。

在上一个教程中，我们学习了 Java 异常。我们知道异常会异常地终止程序的执行。

这就是为什么处理异常很重要。这里列出了在 Java 中处理异常的不同方法。

  • try...catch 块
  • finally 块
  • throw 和 throws 关键字

1. Java try...catch 块​

try-catch 块用于在 Java 中处理异常。以下是 try...catch 块的语法：

try {
  // 代码
}
catch(Exception e) {
  // 代码
}

这里，我们将可能产生异常的代码放在了 try 块中。每个 try 块后面都跟着一个 catch 块。

当发生异常时，它会被 catch 块捕获。catch 块不能脱离 try 块单独使用。

示例：使用 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

在这个例子中，我们尝试将一个数字除以 0。这里，这段代码产生了一个异常。

为了处理这个异常，我们将 5 / 0 这段代码放在了 try 块内。现在当异常发生时，try 块内的其余代码将被跳过。

catch 块捕获了异常，并执行 catch 块内的语句。

如果 try 块中的语句没有生成异常，那么 catch 块将被跳过。

2. Java finally 块​

在 Java 中，无论是否发生异常，finally 块总是会被执行。

finally 块是可选的。并且，对于每个 try 块，只能有一个 finally 块。

finally 块的基本语法是：

try {
  // 代码
}
catch (ExceptionType1 e1) {
  // catch 块
}
finally {
  // finally 块总是执行
}

如果发生异常，finally 块将在 try...catch 块之后执行。否则，它将在 try 块之后执行。对于每个 try 块，只能有一个 finally 块。

示例：使用 finally 块的 Java 异常处理​

class Main {
  public static void main(String[] args) {
    try {
      // 生成异常的代码
      int divideByZero = 5 / 0;
    }

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

    finally {
      System.out.println("这是 finally 块");
    }
  }
}

输出

ArithmeticException => / by zero
这是 finally 块

在上面的示例中，我们在 try 块内部尝试将一个数字除以 0。这里，这段代码生成了一个 ArithmeticException 异常。

异常被 catch 块捕获。然后，执行 finally 块。

注意：使用 finally 块是一种良好的实践。因为它可以包含重要的清理代码，例如，

  • 可能被 return、continue 或 break 意外跳过的代码
  • 关闭文件或连接

3. Java throw 和 throws 关键字​

Java 的 throw 关键字用于显式抛出单个异常。

当我们 throw 一个异常时，程序的流程从 try 块转移到 catch 块。

示例：使用 Java throw 进行异常处理​

class Main {
  public static void divideByZero() {

    // 抛出一个异常
    throw new ArithmeticException("尝试除以 0");
  }

  public static void main(String[] args) {
    divideByZero();
  }
}

输出

线程 "main" 中的异常 java.lang.ArithmeticException: 尝试除以 0
        at Main.divideByZero(Main.java:5)
        at Main.main(Main.java:9)

在上述示例中，我们使用 throw 关键字显式地抛出 ArithmeticException 异常。

类似地，throws 关键字用于声明方法内可能发生的异常类型。它用于方法声明。

示例：Java throws 关键字​

import java.io.*;

class Main {
  // 声明异常类型
  public static void findFile() throws IOException {

    // 可能生成 IOException 的代码
    File newFile = new File("test.txt");
    FileInputStream stream = new FileInputStream(newFile);
  }

  public static void main(String[] args) {
    try {
      findFile();
    }
    catch (IOException e) {
      System.out.println(e);
    }
  }
}

输出

java.io.FileNotFoundException: test.txt (系统找不到指定的文件)

当我们运行这个程序时，如果文件 test.txt 不存在，FileInputStream 会抛出一个 FileNotFoundException，它继承自 IOException 类。

findFile() 方法指定可以抛出 IOException。main() 方法调用这个方法，并在异常被抛出时处理它。

如果一个方法不处理异常，那么在该方法内可能发生的异常类型必须在 throws 子句中指定。

要了解更多，请访问 Java throw 和 throws。

最后于 更新