【Java实战⑦】从入门到精通：Java异常处理实战指南

---

一、Java 异常体系认知

1.1 异常的概念与分类（Error 与 Exception 区别）

在 Java 编程中，异常是指程序在运行时出现的一些不正常情况，这些情况会导致程序的正常流程被中断。异常机制是 Java 提供的一种处理错误的方式，它使得程序在遇到错误时能够有机会进行适当的处理，而不是直接崩溃。

Java 中的异常和错误都继承自Throwable类，Throwable类是 Java 异常体系的根类，它包含了两个主要的子类：Error和Exception。

• Error：Error类及其子类表示的是严重的系统错误，这些错误通常是由系统级问题导致的，比如内存耗尽（OutOfMemoryError ）、栈溢出（StackOverflowError ）、类定义找不到（NoClassDefFoundError）等。这些错误一旦发生，往往意味着程序运行的环境出现了严重问题，程序通常无法继续正常运行，并且很难通过程序自身的代码逻辑来恢复。例如，当系统内存不足时，程序几乎没有办法在不借助外部干预（如增加内存、优化内存使用等）的情况下继续执行。
• Exception：Exception类及其子类表示的是程序运行过程中可以预料到的异常情况，这些异常是程序在正常执行流程中可能出现的意外情况。例如，文件读取时文件不存在（FileNotFoundException）、网络请求超时（SocketTimeoutException）、类型转换错误（ClassCastException ）等。与Error 不同，Exception类型的异常是可以被程序捕获并处理的，通过合理的异常处理机制，程序可以在遇到异常时采取相应的措施，从而避免程序的意外终止，提高程序的健壮性和稳定性。

1.2 受检异常与非受检异常（常见异常举例）

在Exception类中，又可以进一步分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。

• 受检异常：受检异常是指在编译时就必须进行处理的异常。如果一个方法可能抛出受检异常，那么要么在方法内部使用try-catch块来捕获并处理这个异常，要么在方法的声明中使用throws关键字声明抛出这个异常，让调用该方法的代码来处理。受检异常通常表示一些外部环境可能出现的问题，例如：
  • IOException：这是一个与输入输出操作相关的异常，当进行文件读取、写入、网络通信等 I/O 操作时，如果出现错误，就可能抛出这个异常。比如，当尝试打开一个不存在的文件时，会抛出FileNotFoundException，它是IOException的子类。示例代码如下：

import java.io.FileReader;
import java.io.IOException;public class CheckedExceptionExample {public static void main(String[] args) {try {FileReader fileReader = new FileReader("nonexistentFile.txt");} catch (IOException e) {System.out.println("文件未找到，请检查文件路径。");e.printStackTrace();}}
}

• SQLException：在进行数据库操作时，如果出现 SQL 语法错误、连接数据库失败、查询超时等问题，就会抛出这个异常。例如，当执行一条错误的 SQL 语句时，可能会抛出SQLSyntaxErrorException，它是SQLException的子类。
• 非受检异常：非受检异常也称为运行时异常（Runtime Exception），它们是在程序运行时才可能出现的异常，并且编译器不会强制要求对它们进行处理。非受检异常通常是由程序的逻辑错误引起的，例如：
  • NullPointerException：当程序试图访问一个null对象的方法或属性时，就会抛出这个异常。例如：

public class UncheckedExceptionExample {public static void main(String[] args) {String s = null;System.out.println(s.length()); // 这里会抛出NullPointerException}
}

• ArrayIndexOutOfBoundsException：当访问数组时，如果使用的索引超出了数组的有效范围，就会抛出这个异常。比如：

public class ArrayIndexOutOfBoundsExceptionExample {public static void main(String[] args) {int[] array = {1, 2, 3};System.out.println(array[3]); // 这里会抛出ArrayIndexOutOfBoundsException}
}

1.3 异常处理的意义（程序稳定性保障）

异常处理在 Java 编程中具有非常重要的意义，它主要体现在以下几个方面：

• 提高程序的健壮性：通过合理地捕获和处理异常，程序可以在遇到错误时不会轻易崩溃，而是能够采取相应的措施来恢复或者进行错误提示，从而保证程序的正常运行。例如，在一个文件读取的操作中，如果不进行异常处理，当文件不存在时，程序就会直接抛出异常并终止运行；而如果进行了异常处理，程序可以捕获到这个异常，并提示用户文件不存在，让用户进行相应的操作，如重新输入文件路径。
• 增强程序的可读性和可维护性：将异常处理的代码与正常的业务逻辑代码分离，可以使程序的结构更加清晰，易于理解和维护。当程序出现问题时，通过查看异常处理的代码，可以快速定位到问题所在，并且可以方便地对异常处理逻辑进行修改和扩展。
• 改善用户体验：在一个面向用户的应用程序中，如果出现错误时直接抛出异常，用户可能会看到一些难以理解的错误信息，这会影响用户对应用程序的使用体验。而通过异常处理，可以将这些错误信息转化为友好的提示信息，让用户更容易理解和处理。例如，在一个电商应用中，如果用户在下单时出现网络错误，通过异常处理可以提示用户 “网络连接失败，请稍后重试”，而不是让用户看到一堆技术术语的异常信息。

二、异常处理机制（try-catch-finally、throw、throws）

2.1 try-catch 语句（捕获异常与异常处理逻辑）

try-catch语句是 Java 中用于捕获和处理异常的基本结构。其基本语法如下：

try {// 可能会抛出异常的代码
} catch (ExceptionType e) {// 处理异常的代码
}

在上述语法中，try块中放置的是可能会抛出异常的代码。当try块中的代码执行过程中抛出了异常，程序会立即停止执行try块中剩余的代码，并跳转到对应的catch块中执行异常处理代码。catch块中的参数ExceptionType e表示捕获到的异常对象，其中ExceptionType是具体的异常类型，比如IOException、NullPointerException等，e是对该异常对象的引用，通过它可以获取异常的相关信息，如异常的描述信息（e.getMessage()）、异常的堆栈跟踪信息（e.printStackTrace()）等。

下面通过一个简单的除法运算示例来进一步说明try-catch语句的工作原理：

public class TryCatchExample {public static void main(String[] args) {int a = 10;int b = 0;try {int result = a / b; // 这里会抛出ArithmeticException异常System.out.println("结果是：" + result);} catch (ArithmeticException e) {System.out.println("发生了算术异常：" + e.getMessage());e.printStackTrace();}System.out.println("程序继续执行");}
}

在这个例子中，try块中的int result = a / b;语句尝试进行除法运算，由于除数b为 0，这会导致ArithmeticException异常的抛出。当异常抛出后，try块中后续的System.out.println(“结果是：” + result);语句将不会被执行，程序会跳转到catch块中执行异常处理代码。在catch块中，首先打印出异常的描述信息，然后通过e.printStackTrace()方法打印出异常的堆栈跟踪信息，以便于调试。最后，System.out.println(“程序继续执行”);语句会被执行，这表明在处理完异常后，程序可以继续正常执行后续的代码。

2.2 多 catch 块使用（不同异常类型分别处理）

当一段代码可能会抛出多种不同类型的异常时，可以使用多个catch块来分别捕获并处理不同类型的异常。每个catch块可以指定要捕获的具体异常类型，这样就可以针对每种异常采取特定的处理措施，使异常处理更加灵活和精确。

其语法结构如下：

try {// 可能会抛出多种异常的代码
} catch (ExceptionType1 e1) {// 处理ExceptionType1类型异常的代码
} catch (ExceptionType2 e2) {// 处理ExceptionType2类型异常的代码
} catch (ExceptionType3 e3) {// 处理ExceptionType3类型异常的代码
} 
// 可以根据需要添加更多的catch块

例如，下面的代码展示了如何使用多个catch块来处理不同类型的异常：

public class MultipleCatchExample {public static void main(String[] args) {try {String str = null;int length = str.length(); // 这里会抛出NullPointerException异常int num = Integer.parseInt("abc"); // 这里会抛出NumberFormatException异常int result = 10 / 0; // 这里会抛出ArithmeticException异常} catch (NullPointerException e) {System.out.println("发生了空指针异常：" + e.getMessage());e.printStackTrace();} catch (NumberFormatException e) {System.out.println("发生了数字格式异常：" + e.getMessage());e.printStackTrace();} catch (ArithmeticException e) {System.out.println("发生了算术异常：" + e.getMessage());e.printStackTrace();}System.out.println("程序继续执行");}
}

在上述代码中，try块中的代码可能会抛出三种不同类型的异常：NullPointerException、NumberFormatException和ArithmeticException。通过使用三个不同的catch块，分别对这三种异常进行了处理。当try块中的代码抛出NullPointerException异常时，程序会跳转到第一个catch块中执行；当抛出NumberFormatException异常时，会跳转到第二个catch块中执行；当抛出ArithmeticException异常时，会跳转到第三个catch块中执行。每个catch块都根据异常的类型进行了针对性的处理，最后程序继续执行后续的代码。

需要注意的是，多个catch块的顺序很重要，应该将捕获具体异常类型的catch块放在前面，捕获更通用异常类型（如Exception）的catch块放在后面。因为异常处理机制是按照catch块的顺序依次匹配异常类型的，如果将捕获通用异常类型的catch块放在前面，那么后面捕获具体异常类型的catch块将永远不会被执行，这会导致异常处理不够精确。

2.3 finally 语句（资源释放的必选场景）

finally语句是try-catch结构中的一个可选部分，但在许多情况下它非常重要。finally块中的代码无论try块中是否发生异常，也无论catch块是否捕获到异常，都会被执行。这使得finally块成为释放资源（如关闭文件、数据库连接、网络连接等）的理想位置，从而确保资源能够被正确地关闭，避免资源泄漏。

其语法结构如下：

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

下面是一个文件读取的示例，展示了如何使用finally块来关闭文件流：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class FinallyExample {public static void main(String[] args) {BufferedReader reader = null;try {reader = new BufferedReader(new FileReader("example.txt"));String line;while ((line = reader.readLine()) != null) {System.out.println(line);}} catch (IOException e) {System.out.println("读取文件时发生错误：" + e.getMessage());e.printStackTrace();} finally {if (reader != null) {try {reader.close();} catch (IOException e) {System.out.println("关闭文件时发生错误：" + e.getMessage());e.printStackTrace();}}}}
}

在这个例子中，try块中进行文件读取操作，catch块捕获可能发生的IOException异常并进行处理。在finally块中，首先检查reader是否为null（因为如果在创建reader时发生异常，reader可能还没有被成功初始化），如果不为null，则尝试关闭文件流。即使在文件读取过程中发生了异常，finally块中的关闭文件流操作也会被执行，从而确保文件资源被正确释放。

此外，需要注意的是，如果try块或catch块中使用了return语句，finally块中的代码仍然会在return之前执行。例如：

public class FinallyWithReturnExample {public static int test() {try {return 1;} finally {System.out.println("finally块被执行");}}public static void main(String[] args) {int result = test();System.out.println("返回结果是：" + result);}
}

在这个例子中，try块中使用了return 1;语句，但在返回之前，finally块中的System.out.println(“finally块被执行”);语句会先被执行，然后才返回结果。

2.4 throw 与 throws 关键字（手动抛异常与声明异常）

• throw关键字：throw关键字用于在程序中手动抛出异常。当程序执行到throw语句时，会立即抛出一个指定的异常对象，并且程序的执行流程会立即跳转到最近的catch块（如果有匹配的catch块）或者导致程序终止（如果没有匹配的catch块）。通常在业务逻辑中，当遇到一些不符合预期的条件时，可以使用throw关键字手动抛出异常，以通知调用者出现了问题。

例如，在一个方法中进行参数校验时，如果参数不合法，可以抛出IllegalArgumentException异常：

public class ThrowExample {public static void validateAge(int age) {if (age < 0 || age > 150) {throw new IllegalArgumentException("年龄必须在0到150之间");}System.out.println("年龄合法：" + age);}public static void main(String[] args) {try {validateAge(-5);} catch (IllegalArgumentException e) {System.out.println("捕获到异常：" + e.getMessage());e.printStackTrace();}}
}

在上述代码中，validateAge方法用于校验年龄参数。当传入的年龄不在 0 到 150 之间时，使用throw关键字抛出一个IllegalArgumentException异常，并附带错误信息。在main方法中，通过try-catch块捕获并处理这个异常。

• throws关键字：throws关键字用于在方法声明中声明该方法可能抛出的异常。当一个方法中可能会抛出受检异常时，要么在方法内部使用try-catch块来捕获并处理这些异常，要么使用throws关键字将这些异常声明出来，让调用该方法的代码来处理。这样可以将异常处理的责任交给调用者，使方法的调用者能够清楚地知道该方法可能会抛出哪些异常，从而采取相应的处理措施。

例如，一个读取文件的方法可能会抛出IOException异常，使用throws关键字声明如下：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class ThrowsExample {public static String readFile(String filePath) throws IOException {BufferedReader reader = new BufferedReader(new FileReader(filePath));StringBuilder content = new StringBuilder();String line;while ((line = reader.readLine()) != null) {content.append(line).append("\n");}reader.close();return content.toString();}public static void main(String[] args) {try {String content = readFile("nonexistentFile.txt");System.out.println("文件内容是：" + content);} catch (IOException e) {System.out.println("读取文件时发生错误：" + e.getMessage());e.printStackTrace();}}
}

在这个例子中，readFile方法使用throws IOException声明它可能会抛出IOException异常。在main方法中调用readFile方法时，由于readFile方法声明了可能抛出IOException异常，所以在main方法中必须使用try-catch块来捕获并处理这个异常，或者main方法也可以继续使用throws关键字将这个异常声明出去，交给更上层的调用者处理。

需要注意的是，throws关键字只能用于方法声明中，不能用于方法体内部，而且它可以声明抛出多个异常，多个异常之间用逗号隔开，如public void method() throws Exception1, Exception2 {…}。

三、自定义异常与异常最佳实践

3.1 自定义异常定义（继承 Exception 或 RuntimeException）

在 Java 开发中，虽然 Java 自带的异常类能处理很多常见错误，但在实际业务里，常常需要定义符合特定业务逻辑的异常。这时候就可以通过继承Exception类（检查型异常）或RuntimeException类（非检查型异常）来创建自定义异常。

当继承Exception类时，所创建的自定义异常属于检查型异常。这意味着在调用可能抛出这种异常的方法时，必须在代码中显式地捕获并处理它，或者在方法声明中使用throws关键字声明抛出该异常，否则代码将无法通过编译。例如，下面定义一个自定义的检查型异常类CustomCheckedException，用于表示特定业务场景下的检查型异常：

public class CustomCheckedException extends Exception {public CustomCheckedException() {super();}public CustomCheckedException(String message) {super(message);}public CustomCheckedException(String message, Throwable cause) {super(message, cause);}public CustomCheckedException(Throwable cause) {super(cause);}
}

在上述代码中，CustomCheckedException类继承自Exception，通过不同的构造函数，可以根据具体需求创建带有不同信息的异常对象。当在某个方法中可能出现需要抛出CustomCheckedException异常的情况时，例如：

public class CheckedExceptionUsage {public void someMethod() throws CustomCheckedException {// 模拟业务逻辑，满足特定条件时抛出异常boolean condition = true;if (condition) {throw new CustomCheckedException("这是一个自定义的检查型异常");}}
}

在调用someMethod方法时，就必须对可能抛出的CustomCheckedException异常进行处理，如下所示：

public class Main {public static void main(String[] args) {CheckedExceptionUsage usage = new CheckedExceptionUsage();try {usage.someMethod();} catch (CustomCheckedException e) {System.out.println("捕获到自定义检查型异常: " + e.getMessage());e.printStackTrace();}}
}

而当继承RuntimeException类时，创建的自定义异常属于非检查型异常。非检查型异常在编译时不会被强制要求处理，它通常用于表示程序中的逻辑错误，这些错误应该在开发和测试阶段被发现并修复。例如，定义一个自定义的非检查型异常类CustomUncheckedException：

public class CustomUncheckedException extends RuntimeException {public CustomUncheckedException() {super();}public CustomUncheckedException(String message) {super(message);}public CustomUncheckedException(String message, Throwable cause) {super(message, cause);}public CustomUncheckedException(Throwable cause) {super(cause);}
}

在方法中使用这个自定义的非检查型异常时，例如：

public class UncheckedExceptionUsage {public void anotherMethod() {// 模拟业务逻辑，满足特定条件时抛出异常boolean condition = false;if (condition) {throw new CustomUncheckedException("这是一个自定义的非检查型异常");}}
}

调用anotherMethod方法时，可以选择捕获并处理CustomUncheckedException异常，也可以不处理，让异常向上传播由更上层的调用者处理，如下所示：

public class Main {public static void main(String[] args) {UncheckedExceptionUsage usage = new UncheckedExceptionUsage();try {usage.anotherMethod();} catch (CustomUncheckedException e) {System.out.println("捕获到自定义非检查型异常: " + e.getMessage());e.printStackTrace();}}
}

3.2 自定义异常实战案例（用户注册异常处理）

以用户注册功能为例，在实际应用中，用户注册时可能会遇到多种不符合业务规则的情况，比如用户名已存在、密码不符合规则（长度不够、没有包含特定字符等） 等。这时候就可以通过自定义异常来更好地处理这些情况，使代码的逻辑更加清晰，错误处理更加灵活。

首先，定义两个自定义异常类，分别用于表示用户名已存在和密码不符合规则的异常：

// 自定义异常类，表示用户名已存在
public class UsernameExistsException extends RuntimeException {public UsernameExistsException() {super();}public UsernameExistsException(String message) {super(message);}
}// 自定义异常类，表示密码不符合规则
public class PasswordNotMatchException extends RuntimeException {public PasswordNotMatchException() {super();}public PasswordNotMatchException(String message) {super(message);}
}

然后，实现用户注册的业务逻辑方法。在这个方法中，检查用户名是否已存在以及密码是否符合规则，如果不符合则抛出相应的自定义异常：

import java.util.ArrayList;
import java.util.List;public class UserRegistrationService {private static List<String> existingUsernames = new ArrayList<>();static {// 初始化一些已存在的用户名existingUsernames.add("user1");existingUsernames.add("user2");}public void registerUser(String username, String password) {// 检查用户名是否已存在if (existingUsernames.contains(username)) {throw new UsernameExistsException("用户名已存在，请更换用户名");}// 检查密码是否符合规则，这里简单示例要求密码长度至少为6位if (password.length() < 6) {throw new PasswordNotMatchException("密码长度至少为6位");}// 如果用户名和密码都合法，执行注册操作，这里简单示例添加到已存在用户名列表中existingUsernames.add(username);System.out.println("注册成功，欢迎 " + username);}
}

最后，在测试类中调用注册方法，并捕获和处理可能抛出的自定义异常：

public class Main {public static void main(String[] args) {UserRegistrationService service = new UserRegistrationService();try {service.registerUser("user1", "12345"); // 用户名已存在且密码不符合规则} catch (UsernameExistsException e) {System.out.println("注册失败: " + e.getMessage());} catch (PasswordNotMatchException e) {System.out.println("注册失败: " + e.getMessage());}try {service.registerUser("user3", "123456"); // 用户名不存在且密码符合规则，注册成功} catch (UsernameExistsException e) {System.out.println("注册失败: " + e.getMessage());} catch (PasswordNotMatchException e) {System.out.println("注册失败: " + e.getMessage());}}
}

在上述代码中，UserRegistrationService类的registerUser方法负责处理用户注册的逻辑。通过existingUsernames列表来模拟已存在的用户名，在注册时检查用户名是否已存在以及密码是否符合规则。如果不符合规则，就抛出相应的自定义异常。在Main类的main方法中，调用registerUser方法进行注册，并使用try-catch块捕获并处理可能抛出的自定义异常，根据不同的异常类型给出相应的错误提示。

3.3 异常处理最佳实践（避免空 catch 块、异常信息明确）

在进行异常处理时，遵循一些最佳实践可以使代码更加健壮、易于维护和调试。

首先，要避免捕获通用的Exception类而不进行具体的处理。虽然Exception类可以捕获所有类型的异常，但这样做会掩盖具体的异常信息，使得在调试时难以确定问题的根源。例如，下面的代码捕获了通用的Exception类，但没有进行任何具体的处理：

public class BadExceptionHandling {public void someMethod() {try {// 可能会抛出异常的代码int result = 10 / 0;} catch (Exception e) {// 空的catch块，没有任何处理逻辑}}
}

在这个例子中，当int result = 10 / 0;这行代码抛出ArithmeticException异常时，由于catch块中没有任何处理逻辑，很难从代码中得知这里发生了什么错误，这给调试带来了很大的困难。因此，应该捕获具体的异常类型，针对不同类型的异常进行具体的处理，如下所示：

public class GoodExceptionHandling {public void someMethod() {try {int result = 10 / 0;} catch (ArithmeticException e) {System.out.println("发生了算术异常: " + e.getMessage());e.printStackTrace();}}
}

这样，当异常发生时，可以清楚地知道是哪种类型的异常以及异常的具体信息，便于定位和解决问题。

其次，要避免使用空的catch块。空的catch块会捕获异常，但却不进行任何处理，这会导致异常被忽略，使得程序中潜在的问题难以被发现。例如：

public class EmptyCatchBlockExample {public void readFile(String filePath) {try {// 读取文件的代码，可能会抛出IOExceptionjava.io.FileReader reader = new java.io.FileReader(filePath);} catch (java.io.IOException e) {// 空的catch块，没有处理IOException}}
}

在这个例子中，如果文件不存在或读取文件时发生其他 I/O 错误，catch块中的空实现会忽略这些错误，程序可能会继续执行，但结果可能不符合预期。正确的做法是在catch块中添加具体的处理逻辑，比如记录日志、提示用户或进行其他必要的操作：

public class ProperExceptionHandling {public void readFile(String filePath) {try {java.io.FileReader reader = new java.io.FileReader(filePath);} catch (java.io.IOException e) {System.out.println("读取文件时发生错误: " + e.getMessage());e.printStackTrace();}}
}

这样，当异常发生时，程序会打印出错误信息，便于开发者了解问题所在并进行处理。

此外，异常信息要尽可能明确。在抛出异常时，应该提供详细的错误信息，以便在捕获异常时能够准确地知道问题的原因。例如，在自定义异常时，可以在构造函数中传入详细的错误描述：

public class CustomException extends Exception {public CustomException(String message) {super(message);}
}public class ExceptionInfoExample {public void someMethod() throws CustomException {boolean condition = true;if (condition) {throw new CustomException("发生了自定义异常，具体原因是：业务逻辑出现错误，某个条件不满足");}}
}

在捕获这个异常时，就可以通过e.getMessage()方法获取到详细的错误信息，方便调试和定位问题：

public class Main {public static void main(String[] args) {ExceptionInfoExample example = new ExceptionInfoExample();try {example.someMethod();} catch (CustomException e) {System.out.println("捕获到异常: " + e.getMessage());e.printStackTrace();}}
}

3.4 日志记录异常（使用 System.out 与日志框架初步）

在 Java 中，记录异常信息是非常重要的，它有助于在程序出现问题时进行调试和排查错误。常用的记录异常信息的方式有使用System.out打印和使用专业的日志框架。

使用System.out打印异常信息是一种简单直接的方式，例如：

public class SystemOutExceptionExample {public static void main(String[] args) {try {int result = 10 / 0;} catch (ArithmeticException e) {System.out.println("发生异常: " + e.getMessage());e.printStackTrace();}}
}

在上述代码中，通过System.out.println打印异常的描述信息e.getMessage()，并使用e.printStackTrace()打印异常的堆栈跟踪信息，这样可以在控制台看到异常的相关信息。然而，使用System.out打印异常信息存在一些局限性。它主要用于简单的测试和调试场景，在实际的生产环境中，System.out的输出可能会与其他正常的输出信息混杂在一起，难以区分和管理。而且System.out的输出方式不够灵活，无法控制输出的级别、格式以及输出的目标（如文件、数据库等）。

相比之下，使用日志框架可以更有效地记录异常信息。常见的日志框架有Log4j、SLF4J（Simple Logging Facade for Java） 等。Log4j是 Apache 的一个开源日志框架，它提供了灵活的日志记录功能，可以控制日志的输出级别（如 DEBUG、INFO、WARN、ERROR、FATAL 等）、输出位置（如控制台、文件、数据库等）和输出格式。下面是一个使用Log4j记录异常的简单示例：

首先，需要在项目中添加Log4j的依赖（如果使用 Maven，可以在pom.xml文件中添加以下依赖）：

<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version>
</dependency>

然后，在src/main/resources目录下创建log4j.properties配置文件，配置日志的输出方式和格式，例如：

log4j.rootLogger=DEBUG, consolelog4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%p] %c - %m%n

上述配置表示将日志输出到控制台，日志级别为 DEBUG，输出格式包括时间、日志级别、类名和日志信息。

接下来，在代码中使用Log4j记录异常：

import org.apache.log4j.Logger;public class Log4jExceptionExample {private static final Logger logger = Logger.getLogger(Log4jExceptionExample.class);public static void main(String[] args) {try {int result = 10 / 0;} catch (ArithmeticException e) {logger.error("发生算术异常", e);}}
}

在这个例子中，通过Logger.getLogger(Log4jExceptionExample.class)获取一个Logger实例，然后使用logger.error(“发生算术异常”, e)记录异常信息，其中第一个参数是异常的描述信息，第二个参数是异常对象。Log4j会根据配置文件将异常信息按照指定的格式输出到控制台。

SLF4J并不是一个真正的日志实现框架，而是一个日志抽象层，它提供了统一的日志接口，允许在不同的日志实现框架（如Log4j、Logback等）之间进行切换，而无需修改应用程序的代码。使用SLF4J时，首先需要引入SLF4J的依赖，然后再引入具体的日志实现框架（如Logback）的依赖。例如，使用 Maven 添加依赖：

<!-- SLF4J API -->
<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.36</version>
</dependency>
<!-- Logback 实现 -->
<dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.10</version>
</dependency>

在代码中使用SLF4J记录异常的方式与使用Log4j类似：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;public class Slf4jExceptionExample {private static final Logger logger = LoggerFactory.getLogger(Slf4jExceptionExample.class);public static void main(String[] args) {try {int result = 10 / 0;} catch (ArithmeticException e) {logger.error("发生算术异常", e);}}
}

通过使用日志框架，不仅可以更方便地管理和查看异常信息，还可以根据不同的环境和需求灵活地配置日志的输出，提高了程序的可维护性和可扩展性。