Java 中的异常 · ZetCode 中文系列教程

{% raw %} # Java 中的异常原文：http://zetcode.com/lang/java/exceptions/ 在 Java 教程的这一章中，我们将处理异常。 Java 使用异常来处理错误。在执行应用期间，许多事情可能出错。磁盘可能已满，我们无法保存数据。当我们的应用尝试连接到站点时，互联网连接可能会断开。用户将无效数据填充到表单。这些错误可能会使应用崩溃，使其无法响应，并且在某些情况下甚至会损害系统的安全性。程序员有责任处理可以预期的错误。在 Java 中，我们可以识别三种异常：受检的异常，非受检的异常和错误。 ## Java 受检的异常受检的异常是可以预期并从中恢复的错误情况（无效的用户输入，数据库问题，网络中断，文件缺失）。除`RuntimeException`及其子类之外的`Exception`的所有子类都是受检的异常。 `IOException`，`SQLException`或`PrinterException`是受检的异常的示例。 Java 编译器强制将受检的异常捕获或在方法签名中声明（使用`throws`关键字）。 ## Java 非受检的异常非受检的异常是无法预期和无法恢复的错误条件。它们通常是编程错误，无法在运行时处理。非受检的异常是`java.lang.RuntimeException`的子类。 `ArithmeticException`，`NullPointerException`或`BufferOverflowException`属于这组异常。 Java 编译器不强制执行非受检的异常。 ## Java 错误错误是程序员无法解决的严重问题。例如，应用无法处理硬件或系统故障。错误是`java.lang.Error`类的实例。错误的示例包括`InternalError`，`OutOfMemoryError`，`StackOverflowError`或`AssertionError`。错误和运行时异常通常称为非受检的异常。 ## Java `try`，`catch`和`finally` `try`，`catch`和`finally`关键字用于处理异常。 `throws`关键字在方法声明中用于指定哪些异常不在方法内处理，而是传递给程序的下一个更高级别。 `throw`关键字导致抛出已声明的异常实例。引发异常后，运行时系统将尝试查找适当的异常处理器。调用栈是为处理器搜索的方法的层次结构。 ## Java 非受检的异常示例 Java 受检的异常包括`ArrayIndexOutOfBoundsException`，`UnsupportedOperationException`，`NullPointerException`和`InputMismatchException`。 ### `ArrayIndexOutOfBoundsException` 抛出`ArrayIndexOutOfBoundsException`表示已使用非法索引访问了数组。索引为负或大于或等于数组的大小。 `com/zetcode/ArrayIndexOutOfBoundsEx.java` ```java package com.zetcode; public class ArrayIndexOutOfBoundsEx { public static void main(String[] args) { int[] n = { 5, 2, 4, 5, 6, 7, 2 }; System.out.format("The last element in the array is %d%n", n[n.length]); } } ``` 上面的程序中有一个错误。我们尝试访问一个不存在的元素。这是编程错误。没有理由要处理此错误：必须固定代码。 ```java System.out.format("The last element in the array is %d%n", n[n.length]); ``` 数组索引从零开始。因此，最后一个索引是`n.length - 1`。 ```java $ java ArrayIndexOutOfBoundsEx.java Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 7 at com.zetcode.ArrayIndexOutOfBoundsEx.main(ArrayIndexOutOfBoundsEx.java:9) ``` 运行系统将抛出`java.lang.ArrayIndexOutOfBoundsException`。这是非受检的异常的示例。 ### `UnsupportedOperationException` 抛出`UnsupportedOperationException`，表明不支持所请求的操作。 `com/zetcode/UnsupportedOperationEx.java` ```java package com.zetcode; import java.util.List; public class UnsupportedOperationEx { public static void main(String[] args) { var words = List.of("sky", "blue", "forest", "lake", "river"); words.add("ocean"); System.out.println(words); } } ``` 用`List.of()`工厂方法创建一个不可变列表。不可变列表不支持`add()`方法；因此，我们在运行示例时抛出了`UnsupportedOperationException`。 ### `NullPointerException` 当应用尝试使用具有`null`值的对象引用时，将引发`NullPointerException`。例如，我们在`null`引用所引用的对象上调用实例方法。 `com/zetcode/NullPointerEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class NullPointerEx { public static void main(String[] args) { List<String> words = new ArrayList<>() {{ add("sky"); add("blue"); add("cloud"); add(null); add("ocean"); }}; words.forEach(word -> { System.out.printf("The %s word has %d letters%n", word, word.length()); }); } } ``` 该示例遍历字符串列表，并确定每个字符串的长度。在`null`值上调用`length()`会导致`NullPointerException`。为了解决这个问题，我们可以在调用`length()`之前从检查列表中删除`null`值的所有`null`值。 ### `InputMismatchException` `Scanner`类抛出`InputMismatchException`，以指示检索到的令牌与预期类型的模式不匹配。此异常是非受检的异常的示例。编译器不强制我们处理此异常。 `com/zetcode/InputMismatchEx.java` ```java package com.zetcode; import java.util.InputMismatchException; import java.util.Scanner; import java.util.logging.Level; import java.util.logging.Logger; public class InputMismatchEx { public static void main(String[] args) { System.out.print("Enter an integer: "); try { Scanner sc = new Scanner(System.in); int x = sc.nextInt(); System.out.println(x); } catch (InputMismatchException e) { Logger.getLogger(InputMismatchEx.class.getName()).log(Level.SEVERE, e.getMessage(), e); } } ``` 容易出错的代码位于`try`块中。如果引发异常，则代码跳至`catch`块。引发的异常类必须与`catch`关键字后面的异常匹配。 ```java try { Scanner sc = new Scanner(System.in); int x = sc.nextInt(); System.out.println(x); } ``` `try`关键字定义了可能引发异常的语句块。 ```java } catch (InputMismatchException e) { Logger.getLogger(InputMismatchEx.class.getName()).log(Level.SEVERE, e.getMessage(), e); } ``` 异常在`catch`块中处理。我们使用`Logger`类记录错误。 ## 受检的异常 Java 受检的异常包括`SQLException`，`IOException`或`ParseException`。 ### `SQLException` 使用数据库时发生`SQLException`。 `com/zetcode/MySqlVersionEx.java` ```java package com.zetcode; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.logging.Level; import java.util.logging.Logger; public class MySqlVersionEx { public static void main(String[] args) { Connection con = null; Statement st = null; ResultSet rs = null; String url = "jdbc:mysql://localhost:3306/testdb?useSsl=false"; String user = "testuser"; String password = "test623"; try { con = DriverManager.getConnection(url, user, password); st = con.createStatement(); rs = st.executeQuery("SELECT VERSION()"); if (rs.next()) { System.out.println(rs.getString(1)); } } catch (SQLException ex) { Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } finally { if (rs != null) { try { rs.close(); } catch (SQLException ex) { Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } } if (st != null) { try { st.close(); } catch (SQLException ex) { Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } } if (con != null) { try { con.close(); } catch (SQLException ex) { Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } } } } } ``` 该示例连接到 MySQL 数据库并找出数据库系统的版本。连接数据库很容易出错。 ```java try { con = DriverManager.getConnection(url, user, password); st = con.createStatement(); rs = st.executeQuery("SELECT VERSION()"); if (rs.next()) { System.out.println(rs.getString(1)); } } ``` 可能导致错误的代码位于`try`块中。 ```java } catch (SQLException ex) { Logger lgr = Logger.getLogger(Version.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } ``` 发生异常时，我们跳至`catch`块。我们通过记录发生的情况来处理异常。 ```java } finally { if (rs != null) { try { rs.close(); } catch (SQLException ex) { Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } } if (st != null) { try { st.close(); } catch (SQLException ex) { Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } } if (con != null) { try { con.close(); } catch (SQLException ex) { Logger lgr = Logger.getLogger(MySqlVersionEx.class.getName()); lgr.log(Level.SEVERE, ex.getMessage(), ex); } } } ``` 无论是否接收到异常，都将执行`finally`块。我们正在尝试关闭资源。即使在此过程中，也可能会有异常。因此，我们还有其他`try/catch`块。 ### `IOException` 输入/输出操作失败时，抛出`IOException`。这可能是由于权限不足或文件名错误造成的。 `com/zetcode/IOExceptionEx.java` ```java package com.zetcode; import java.io.FileReader; import java.io.IOException; import java.nio.charset.StandardCharsets; public class IOExceptionEx { private static FileReader fr; public static void main(String[] args) { try { char[] buf = new char[1024]; fr = new FileReader("src/resources/data.txt", StandardCharsets.UTF_8); while (fr.read(buf) != -1) { System.out.println(buf); } } catch (IOException e) { e.printStackTrace(); } finally { if (fr != null) { try { fr.close(); } catch (IOException e) { e.printStackTrace(); } } } } } ``` 当我们从文件中读取数据时，我们需要处理`IOException`。当我们尝试使用`read()`读取数据并使用`close()`关闭读取器时，可能会引发异常。 ### `ParseException` 解析操作失败时，将引发`ParseException`。 `com/zetcode/ParseExceptionEx.java` ```java package com.zetcode; import java.text.NumberFormat; import java.text.ParseException; import java.util.Locale; public class ParseExceptionEx { public static void main(String[] args) { NumberFormat nf = NumberFormat.getInstance(new Locale("sk", "SK")); nf.setMaximumFractionDigits(3); try { Number num = nf.parse("150000,456"); System.out.println(num.doubleValue()); } catch (ParseException e) { e.printStackTrace(); } } } ``` 在示例中，我们将本地化的数字值解析为 Java `Number`。我们使用`try/catch`语句处理`ParseException`。 ## Java 抛出异常 `Throwable`类是 Java 语言中所有错误和异常的超类。 Java 虚拟机仅抛出属于此类（或其子类之一）的实例的对象，或者 Java `throw`语句可以抛出该对象。同样，在`catch`子句中，只有此类或其子类之一可以作为参数类型。程序员可以使用`throw`关键字引发异常。异常通常在引发异常的地方进行处理。方法可以通过在方法定义的末尾使用`throws`关键字来摆脱处理异常的责任。关键字后是该方法引发的所有异常的逗号分隔列表。被抛出的异常在调用栈中传播，并寻找最接近的匹配项。 `com/zetcode/ThrowingExceptions.java` ```java package com.zetcode; import java.util.InputMismatchException; import java.util.Scanner; import java.util.logging.Level; import java.util.logging.Logger; public class ThrowingExceptions { public static void main(String[] args) { System.out.println("Enter your age: "); try { Scanner sc = new Scanner(System.in); short age = sc.nextShort(); if (age <= 0 || age > 130) { throw new IllegalArgumentException("Incorrect age"); } System.out.format("Your age is: %d %n", age); } catch (IllegalArgumentException | InputMismatchException e) { Logger.getLogger(ThrowingExceptions.class.getName()).log(Level.SEVERE, e.getMessage(), e); } } } ``` 在示例中，我们要求用户输入他的年龄。我们读取该值，如果该值超出预期的人类年龄范围，则会引发异常。 ```java if (age <= 0 || age > 130) { throw new IllegalArgumentException("Incorrect age"); } ``` 年龄不能为负值，也没有年龄超过 130 岁的记录。如果该值超出此范围，则抛出内置`IllegalArgumentException`。抛出此异常表示方法已传递了非法或不适当的参数。 ```java } catch (IllegalArgumentException | InputMismatchException e) { Logger.getLogger(ThrowingExceptions.class.getName()).log(Level.SEVERE, e.getMessage(), e); } ``` 从 Java 7 开始，可以在一个`catch`子句中捕获多个异常。但是，这些异常不能是彼此的子类。例如，`IOException`和`FileNotFoundException`不能在一个`catch`语句中使用。下面的示例将说明如何将处理异常的责任传递给其他方法。 `thermopylae.txt` ```java The Battle of Thermopylae was fought between an alliance of Greek city-states, led by King Leonidas of Sparta, and the Persian Empire of Xerxes I over the course of three days, during the second Persian invasion of Greece. ``` 我们使用此文本文件。 `com/zetcode/ThrowingExceptions2.java` ```java package com.zetcode; import java.io.BufferedReader; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; public class ThrowingExceptions2 { public static void readFileContents(String fname) throws IOException { BufferedReader br = null; Path myPath = Paths.get(fname); try { br = Files.newBufferedReader(myPath, StandardCharsets.UTF_8); String line; while ((line = br.readLine()) != null) { System.out.println(line); } } finally { if (br != null) { br.close(); } } } public static void main(String[] args) throws IOException { String fileName = "src/main/resources/thermopylae.txt"; readFileContents(fileName); } } ``` 本示例读取文本文件的内容。 `readFileContents()`和`main()`方法都不处理潜在的`IOException`；我们让 JVM 处理它。 ```java public static void readFileContents(String fname) throws IOException { ``` 当我们从文件读取时，会抛出`IOException`。 `readFileContents()`方法引发异常。处理这些异常的任务委托给调用者。 ```java public static void main(String[] args) throws IOException { String fileName = "src/main/resources/thermopylae.txt"; readFileContents(fileName); } ``` `main()`方法也会抛出`IOException`。如果有这样的异常，它将由 JVM 处理。 ## Java `try-with-resources`语句 `try-with-resources`语句是一种特殊的`try`语句。它是 Java 7 中引入的。在括号中，我们放置了一个或多个资源。这些资源将在语句末尾自动关闭。我们不必手动关闭资源。 `com/zetcode/TryWithResources.java` ```java package com.zetcode; import java.io.BufferedReader; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.logging.Level; import java.util.logging.Logger; public class TryWithResources { public static void main(String[] args) { String fileName = "src/main/resources/thermopylae.txt"; Path myPath = Paths.get(fileName); try (BufferedReader br = Files.newBufferedReader(myPath, StandardCharsets.UTF_8)) { String line; while ((line = br.readLine()) != null) { System.out.println(line); } } catch (IOException ex) { Logger.getLogger(TryWithResources.class.getName()).log(Level.SEVERE, ex.getMessage(), ex); } } } ``` 在示例中，我们读取文件的内容并使用`try-with-resources`语句。 ```java try (BufferedReader br = Files.newBufferedReader(myPath, StandardCharsets.UTF_8)) { ... ``` 打开的文件是必须关闭的资源。资源放置在`try`语句的方括号之间。无论`try`语句是正常完成还是突然完成，输入流都将关闭。 ## Java 自定义异常自定义异常是用户定义的异常类，它们扩展了`Exception`类或`RuntimeException`类。使用`throw`关键字可以消除自定义异常。 `com/zetcode/JavaCustomException.java` ```java package com.zetcode; class BigValueException extends Exception { public BigValueException(String message) { super(message); } } public class JavaCustomException { public static void main(String[] args) { int x = 340004; final int LIMIT = 333; try { if (x > LIMIT) { throw new BigValueException("Exceeded the maximum value"); } } catch (BigValueException e) { System.out.println(e.getMessage()); } } } ``` 我们假定存在无法处理大量数字的情况。 ```java class BigValueException extends Exception { public BigValueException(String message) { super(message); } } ``` 我们有一个`BigValueException`类。该类派生自内置的`Exception`类。它使用`super`关键字将错误消息传递给父类。 ```java final int LIMIT = 333; ``` 大于此常数的数字在我们的程序中被视为`big`。 ```java if (x > LIMIT) { throw new BigValueException("Exceeded the maximum value"); } ``` 如果该值大于限制，则抛出自定义异常。我们给异常消息`"Exceeded the maximum value"`。 ```java } catch (BigValueException e) { System.out.println(e.getMessage()); } ``` 我们捕获到异常并将其消息打印到控制台。在 Java 教程的这一部分中，我们讨论了 Java 中的异常。 {% endraw %}