Java 异常处理

异常的概念

Java中的异常是指在程序运行过程中出现的问题或错误。异常可以分为两种类型：可检查异常（checked exceptions）和不可检查异常（unchecked exceptions）。

可检查异常是指在代码中必须明确处理的异常，它们是Exception类及其子类的实例。在使用可检查异常时，开发者必须使用try-catch语句块捕获并处理这些异常，或者在方法声明中使用throws关键字声明该异常。如果不处理可检查异常，编译器会报错。

不可检查异常是指RuntimeException及其子类的实例，它们通常由程序错误引起，如数组越界、空指针引用等。与可检查异常不同的是，对于不可检查异常，在代码中不需要使用try-catch捕获或者在方法声明中使用throws声明异常。当不可检查异常发生时，程序会中断并抛出异常。

Java提供了一些常见的异常类型，如ArithmeticException、NullPointerException、ArrayIndexOutOfBoundsException等。此外，开发者也可以自定义异常，通过继承Exception类或RuntimeException类来创建自己的异常类。

通过使用异常处理机制，可以使程序更加健壮和容错，提高程序的可维护性和可读性，避免程序的崩溃或异常退出。

异常的体系

Java异常体系是由Throwable类、其子类Exception和Error以及它们各自的子类组成的。Throwable是所有异常的父类，分为两个分支：Exception和Error。

Exception

Exception分支是可检查异常的根类，它又分为两类：RuntimeException 和 非RuntimeException（也称为checked exceptions）。

RuntimeException

RuntimeException及其子类表示程序的逻辑错误或不合理使用API引起的异常，通常是由程序员的错误引起的。这些异常通常可以通过改进代码来避免，因此Java编译器对于这类异常不会强制要求进行异常处理。常见的RuntimeException包括：

• NullPointerException：当一个null对象被访问时引发的异常。
• IndexOutOfBoundsException：访问数组或集合时，索引越界引发的异常。
• IllegalArgumentException：传递给方法的参数不合法引发的异常。
• ArithmeticException：算术运算异常，如除以零。

非 RuntimeException

非 RuntimeException（checked exceptions），这些是Exception的其他子类，需要在代码中明确处理。Java编译器会在编译时强制要求进行处理，通常通过使用try-catch语句块捕获异常或者在方法签名中声明抛出异常。常见的checked exceptions有：

• IOException：处理输入输出操作时引发的异常。
• SQLException：处理数据库操作时引发的异常。
• ClassNotFoundException：找不到类时引发的异常。
• InterruptedException：线程被中断时引发的异常。

Error

Error是指在程序运行过程中发生的严重错误，通常表示虚拟机无法解决的问题。这些错误不应该被应用程序捕获和处理，通常在发生时会导致程序的非正常终止。常见的Error包括OutOfMemoryError（内存不足）和StackOverflowError（栈溢出）等。

异常体系继承图：

try-catch 关键字

try-catch关键字是Java中用于处理异常的机制。通过使用try-catch语句块，可以捕获并处理可能发生的异常，避免程序崩溃。

在try块中，我们编写可能抛出异常的代码。当代码块中的异常发生时，程序会立即跳转到catch块中，并执行catch块中的代码，以处理异常。catch块中的代码是用于处理异常的逻辑，可以根据具体情况进行处理，如打印错误信息、记录日志等。

try-catch语句块的基本语法如下：

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 exception1) {
    // 处理ExceptionType1类型的异常
} catch (ExceptionType2 exception2) {
    // 处理ExceptionType2类型的异常
} finally {
    // 不管是否发生异常，都会执行的代码
}

在try-catch语句块中，可以捕获多种类型的异常，并分别处理。如果一个catch块捕获到了异常，那么后续的catch块将不再执行。

另外，还可以使用多个catch块来捕获同一类型的异常，并按照不同的处理逻辑进行处理。

最后，finally块定义的代码不论是否发生异常，都会执行。通常用于释放资源或进行清理操作。

总之，try-catch关键字是Java中用于处理异常的重要机制，可以保证程序的稳定性和可靠性，提供有用的错误信息，避免程序崩溃。

throw 关键字

throw关键字用于在代码中手动抛出一个异常。它的使用方式是在throw关键字后面跟上要抛出的异常对象。

使用throw关键字可以在任何地方抛出异常，包括方法中、构造函数中、静态初始化块中等。一旦使用throw关键字抛出异常，程序立即停止执行当前代码块，并且异常会被传递到上一级调用栈中的catch块进行处理。

下面是一个使用throw关键字抛出异常的示例：

public class Example {
    public static void divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        int result = a / b;
        System.out.println("结果为：" + result);
    }
    
    public static void main(String[] args) {
        try {
            divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }
}

在上面的示例中，divide方法中使用throw关键字抛出了一个ArithmeticException异常。在main方法中调用divide方法时，由于除数为0，会抛出该异常。然后在catch块中捕获该异常，并输出异常的详细信息。

通过使用throw关键字，我们可以在代码中主动抛出异常，以便在出现错误或问题时提供有用的错误信息，并且可以控制异常的传递和处理方式。

throws 关键字

throws关键字在Java中用于声明可能会抛出的异常类型。当某个方法可能会引发异常，但是不想在该方法内部处理异常时，可以使用throws关键字将异常抛给该方法的调用者来处理。

使用throws关键字的语法如下：

public void methodName() throws ExceptionType1, ExceptionType2, ... {
    // 方法体
}

在方法声明中，通过throws关键字后面的异常类型列表来指定可能会抛出的异常类型。当方法内部发生这些异常时，方法会立即终止，并将异常抛给调用方来处理。

使用throws关键字的主要目的是将异常的处理责任交给方法的调用者。调用者可以选择捕获并处理异常，或者继续将异常抛给更高层的调用者，直到异常被捕获或程序终止。

需要注意的是，如果一个方法声明了throws关键字，那么调用该方法时，必须要么在调用处使用try-catch语句块来捕获异常，要么继续向上层调用者抛出异常，否则会编译错误。

throws关键字只是一种声明，不是处理异常的实际方式。实际的异常处理应该在调用方法的地方进行。

throws抛出子父类异常的处理

在Java中，当一个方法声明使用throws关键字抛出异常时，可以抛出该异常的子类或父类异常。

抛出子类异常

如果一个方法声明抛出了某个异常类型的子类异常，那么在调用该方法时可以捕获该子类异常，或者捕获该异常的父类异常。

public void method() throws SubException {
    // 方法体
}

在调用method()方法时，可以捕获SubException异常或其父类Exception异常。

try {
    method();
} catch (SubException e) {
    // 处理SubException异常
} catch (Exception e) {
    // 处理Exception异常
}

抛出父类异常

如果一个方法声明抛出了某个异常类型的父类异常，那么在调用该方法时只能捕获该异常的父类异常，而不能捕获该异常的子类异常。

public void method() throws ParentException {
    // 方法体
}

在调用method()方法时，只能捕获ParentException异常，而无法捕获其子类SubException异常。

try {
    method();
} catch (ParentException e) {
    // 处理ParentException异常
}

需要注意的是，抛出子类异常或父类异常是为了提供更加灵活的异常处理方式。但在实际编程中，应该根据具体情况选择抛出合适的异常类型，以提供更加精确和有意义的异常信息。

finally 关键字

finally关键字是Java中用于定义一段无论是否发生异常都会执行的代码块。无论try块中是否发生异常，finally块中的代码都会被执行。

finally块通常用于释放资源、关闭文件、数据库连接等操作，以确保在任何情况下都能执行必要的清理工作。

以下是finally块的基本语法：

try {
    // 可能抛出异常的代码
} catch (ExceptionType exception) {
    // 处理异常
} finally {
    // 不论是否发生异常，都会执行的代码
}

无论异常是否被捕获，finally块中的代码都会被执行。如果在catch块中抛出了新的异常，finally块中的代码会在新的异常被抛出之前执行。

在某些情况下，finally块可以不与catch块一起使用，只用于确保一段代码的执行。例如，当使用try-with-resources语句来管理资源时，可以将资源关闭的代码放在finally块中。

总之，finally关键字可以保证无论是否发生异常，都能执行一段代码，用于清理资源或进行必要的操作。它是异常处理机制的一部分，确保程序的可靠性和稳定性。

内置异常类

在Java中，有一些内置的异常类，用于处理特定类型的异常情况。以下是一些常见的内置异常类：

• ArithmeticException（算术异常）：当发生算术运算错误时抛出，如除以零。
• ArrayIndexOutOfBoundsException（数组越界异常）：在访问数组元素时，索引超出数组范围时抛出。
• NullPointerException（空指针异常）：当引用一个空对象时，调用该对象的方法或访问其属性时抛出。
• IllegalArgumentException（非法参数异常）：当传递给方法的参数不合法时抛出，如传递负数给要求正数的方法。
• FileNotFoundException（文件未找到异常）：当尝试打开一个不存在的文件时抛出。
• IOException（输入输出异常）：当发生输入或输出操作失败时抛出，如读取文件失败。
• ClassNotFoundException（类未找到异常）：当试图加载不存在的类时抛出。
• InterruptedException（线程中断异常）：当一个线程在等待、睡眠或被阻塞时被中断时抛出。

这些是Java中的一些常见的内置异常类，它们可以帮助我们处理不同类型的异常情况。我们可以使用try-catch语句来捕获并处理这些异常。

自定义异常类

在Java中，我们可以自定义异常类来处理特定的异常情况。自定义异常类通常继承自Java提供的Exception类或其子类。以下是自定义异常类的一般步骤：

1. 创建一个新的类，命名为你想要的异常名称，并继承自Exception类或其子类。
2. 在异常类中添加构造方法，用于初始化异常对象。
3. 可以添加额外的方法或属性来定制你的异常类。
4. 可以选择覆盖Exception类中的一些方法，以适应你的异常类的需求。

以下是一个简单的自定义异常类的示例：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

在使用自定义异常类时，可以像使用内置异常类一样使用try-catch语句来捕获并处理异常。例如：

try {
    // 可能会抛出CustomException的代码段
    throw new CustomException("这是一个自定义异常");
} catch (CustomException e) {
    System.out.println(e.getMessage()); // 打印异常信息
    e.printStackTrace(); // 打印异常堆栈信息
}

通过自定义异常类，我们可以更好地处理程序中的特定异常情况，并提供有用的错误信息。这有助于我们提高程序的可读性和可靠性。

实际应用

以下是一个简单的例子，展示了在一个银行账户管理系统中如何使用自定义异常类：

// 自定义异常类：当账户余额不足时抛出该异常
public class InsufficientBalanceException extends Exception {
    public InsufficientBalanceException() {
        super("Insufficient balance in the account.");
    }
}

// 银行账户类
public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        balance = initialBalance;
    }

    public void withdraw(double amount) throws InsufficientBalanceException {
        if (amount > balance) {
            throw new InsufficientBalanceException(); // 抛出自定义异常
        }
        balance -= amount;
    }
}

// 使用自定义异常的示例
public class BankApplication {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);

        try {
            account.withdraw(1500); // 尝试取出超过余额的金额
        } catch (InsufficientBalanceException e) {
            System.out.println("Withdrawal failed: " + e.getMessage()); // 捕获并处理自定义异常
        }
    }
}

在上述示例中，我们定义了一个自定义异常类InsufficientBalanceException，用于表示当账户余额不足时的异常情况。在BankAccount类中的withdraw方法中，如果取款金额超过了账户余额，就会抛出InsufficientBalanceException异常。

在BankApplication类的主方法中，我们创建了一个账户对象，并尝试进行一次超过余额的取款操作。由于余额不足，withdraw方法会抛出InsufficientBalanceException异常，然后我们使用try-catch语句块捕获并处理该异常，打印出相应的错误信息。

这个例子展示了如何在项目中应用自定义异常类来处理特定的业务逻辑异常，使得代码更具可读性和可维护性。你可以根据具体的项目需求和异常情况，设计和使用自定义异常类来提高代码的健壮性和可靠性。