try-catch 是 Java 异常处理机制的核心部分，它允许你“捕获”程序在运行时可能发生的错误（异常），并对其进行处理，而不是让程序直接崩溃，这使得程序更加健壮和用户友好。

为什么需要 try-catch？

想象一下,你正在写一个程序，需要从用户那里读取一个数字，然后计算它的倒数。

public class WithoutTryCatch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数字: ");
        String input = scanner.nextLine();
        // 用户输入 "abc"
        int number = Integer.parseInt(input); // 这里会抛出异常！
        int result = 10 / number;
        System.out.println("计算结果是: " + result);
    }
}

如果用户输入 abc，Integer.parseInt("abc") 就无法将字符串转换为整数，程序会抛出 NumberFormatException，然后整个程序就会中断，并打印出一长串红色的错误信息（堆栈跟踪），这非常不友好。

try-catch 就是为了解决这个问题而生。

try-catch 的基本语法

try-catch 的基本结构如下：

try {
    // 可能会抛出异常的代码块
    // JVM会在这里监控异常的发生
} catch (异常类型1 变量名1) {
    // 当try块中发生异常类型1时，执行这里的代码
    // 变量名1 代表被捕获的异常对象
} catch (异常类型2 变量名2) {
    // 当try块中发生异常类型2时，执行这里的代码
}
// ... 可以有多个 catch 块
// finally 块是可选的
finally {
    // 无论是否发生异常，这里的代码都会被执行
    // 通常用于资源释放（如关闭文件、数据库连接等）
}

工作原理：

1. 执行 try 块：程序首先尝试执行 try 块中的代码。
2. 监控异常：在执行 try 块的过程中，JVM 会时刻监控是否有异常发生。
3. 发生异常：
   • try 块中的某一行代码抛出了一个异常，JVM 会立即中断 try 块中剩余代码的执行。
   • JVM 会去检查 catch 块，寻找一个与抛出的异常类型匹配的 catch 块。
   • 匹配规则：catch 块中声明的异常类型与抛出的异常类型相同，或者是抛出异常的父类。catch (Exception e) 可以捕获所有标准异常，因为 Exception 是几乎所有异常的父类。
   • 一旦找到匹配的 catch 块，程序就会执行该 catch 块中的代码。
4. 未发生异常：try 块中的代码全部执行完毕，没有任何异常发生，那么所有的 catch 块都会被跳过。
5. finally 块：无论是否发生异常，finally 块中的代码都一定会被执行，这通常用于执行一些“清理”工作，比如关闭文件流、数据库连接等，确保资源被正确释放。

实战示例

我们用 try-catch 来改进上面的例子。

import java.util.Scanner;
public class WithTryCatch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数字: ");
        String input = scanner.nextLine();
        try {
            int number = Integer.parseInt(input); // 可能抛出 NumberFormatException
            int result = 10 / number;          // 可能抛出 ArithmeticException (除数为0)
            System.out.println("计算结果是: " + result);
        } catch (NumberFormatException e) {
            // 捕获数字格式异常
            System.out.println("错误：您输入的不是一个有效的整数！");
            // e.printStackTrace(); // 可以打印出详细的错误信息，方便调试
        } catch (ArithmeticException e) {
            // 捕获算术异常（如除以0）
            System.out.println("错误：不能除以零！");
        } finally {
            // 无论发生什么，finally块里的代码都会执行
            System.out.println("程序执行完毕。");
            scanner.close(); // 在这里关闭 Scanner，防止资源泄露
        }
    }
}

运行场景分析：

1. 输入 5：

   
   （图片来源网络，侵删）
   • try 块正常执行，number 为 5，result 为 2。
   • 打印 "计算结果是: 2"。
   • 跳过所有 catch 块。
   • 执行 finally 块，打印 "程序执行完毕。"

2. 输入 abc：

   • 执行 Integer.parseInt("abc") 时，抛出 NumberFormatException。
   • try 块立即中断，10 / number 不会执行。
   • JVM 寻找匹配的 catch 块，找到 catch (NumberFormatException e)。
   • 执行该 catch 块，打印 "错误：您输入的不是一个有效的整数！"。
   • 执行 finally 块，打印 "程序执行完毕。"

3. 输入 0：

   • try 块执行 Integer.parseInt("0")，成功，number 为 0。
   • 执行 10 / 0，抛出 ArithmeticException。
   • try 块立即中断。
   • JVM 寻找匹配的 catch 块。NumberFormatException 不匹配，但 ArithmeticException 匹配。
   • 执行 catch (ArithmeticException e)，打印 "错误：不能除以零！"。
   • 执行 finally 块，打印 "程序执行完毕。"

异常的层次结构

理解异常的层次结构对于正确使用 catch 块至关重要，Java 的异常体系主要分为两大类：

• Error (错误)：由 JVM 系统内部错误或资源耗尽引起。OutOfMemoryError, StackOverflowError，这些通常是不可恢复的，我们不应该在代码中使用 try-catch 去捕获它们，而应该让程序终止。

• Exception (异常)：可以被程序捕获和处理的异常，它又分为两类：

  • RuntimeException (运行时异常)：也称为“未检查异常”（Unchecked Exception），这类异常通常是由于编程逻辑错误引起的，NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException，Java 编译器不会强制你处理它们，你可以选择捕获，也可以选择不捕获。
  • Checked Exception (受检异常)：也称为“已检查异常”，这类异常不是由编程错误引起的，而是外部因素（如文件不存在、网络中断、数据库连接失败）导致的，Java 编译器强制你必须在代码中处理它们，要么用 try-catch 捕获，要么用 throws 关键字声明抛出。

常见异常示例：

try-with-resources (Java 7+ 新特性)

这是一个非常实用和安全的特性,用于自动管理资源（如 InputStream, OutputStream, Connection, Scanner 等），只要一个类实现了 AutoCloseable 接口，就可以使用 try-with-resources。

传统方式 (需要 finally 来关闭资源)：

Scanner scanner = null;
try {
    scanner = new Scanner(new File("test.txt"));
    // 使用 scanner...
} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    // 必须手动关闭，防止资源泄露
    if (scanner != null) {
        scanner.close();
    }
}

try-with-resources 方式：

// try() 括号中声明的资源，会在 try 块执行完毕后自动关闭
try (Scanner scanner = new Scanner(new File("test.txt"))) {
    // 使用 scanner...
    // ... 即使这里发生异常，scanner.close() 也会被自动调用
} catch (FileNotFoundException e) {
    e.printStackTrace();
}
// 不需要 finally 块！

优点：

1. 代码简洁：省去了 finally 块和 null 检查。
2. 更安全：即使 try 块中发生异常，资源也一定会被关闭。
3. 可以同时管理多个资源：用分号隔开即可。

   try (FileInputStream fis = new FileInputStream("input.txt");
        FileOutputStream fos = new FileOutputStream("output.txt")) {
       // ...
   } catch (IOException e) {
       // ...
   }

最佳实践

1. 只捕获你知道如何处理的异常：不要用一个笼统的 catch (Exception e) 去捕获所有异常，因为它可能会掩盖掉你本应该处理的其他特定问题。
2. 尽可能具体：优先捕获更具体的异常，而不是它的父类，先捕获 FileNotFoundException，再捕获更通用的 IOException。
3. 不要“吞掉”异常：在 catch 块中只打印一个简单的信息然后什么都不做，这会隐藏问题，使得调试变得非常困难，至少应该打印堆栈跟踪 e.printStackTrace() 或使用日志框架记录下来。
4. 使用 try-with-resources：对于所有实现了 AutoCloseable 的资源，都应优先使用 try-with-resources。
5. 避免在 finally 块中返回：如果在 try 块或 catch 块中有 return 语句，finally 块仍然会执行，如果在 finally 块中也 return，它会覆盖掉之前的 return 值，这通常不是你想要的行为。

掌握 try-catch 是成为一名合格 Java 程序员的必备技能，它能极大地提升你程序的稳定性和可维护性。