Java中的异常情况处理，零基础小白到精通，收藏这篇就够了-育师

文章目录

一、什么是异常
- 1.1 异常的概念
- 1.2 异常的分类
二、异常的体系结构
三、异常的处理
- 3.1 异常的抛出
- 3.2 异常的捕获与处理
- 3.3 异常的处理流程
四、自定义异常类
- 4.1 自定义异常类的规则
- 4.2 自定义异常案例

一、什么是异常

三、异常的处理

3.1 异常的抛出

在Java中，异常的抛出是通过使用throw关键字来实现的。throw关键字用于抛出一个异常对象，将异常传递给调用者或上层调用栈。

以下是异常的抛出示例：

public class Example { public static void main(String[] args) { try { int result = divide(10, 0); // 调用自定义方法 System.out.println("结果：" + result); } catch (ArithmeticException e) { System.out.println("发生了算术异常：" + e.getMessage()); } } public static int divide(int num1, int num2) { if (num2 == 0) { throw new ArithmeticException("除数不能为零"); // 抛出算术异常 } return num1 / num2; } }

在上面的示例中，divide()方法用于计算两个数的除法操作。如果除数为零，将会抛出一个算术异常（ArithmeticException）。在main()方法中，我们调用了divide()方法，并使用try-catch块来捕获可能抛出的异常。如果捕获到算术异常，将会输出相应的错误信息。

另外，除了手动抛出异常，Java还提供了许多内置的异常类，例如NullPointerException、ArrayIndexOutOfBoundsException等。这些异常类可以在特定情况下自动抛出，无需显式使用throw关键字。

以下是一个示例，演示了数组越界异常的自动抛出：

public class ArrayExample { public static void main(String[] args) { int[] arr = {1, 2, 3}; try { int value = arr[5]; // 数组越界，将抛出ArrayIndexOutOfBoundsException异常 } catch (ArrayIndexOutOfBoundsException e) { System.out.println("发生了数组越界异常：" + e.getMessage()); } } }

在上面的示例中，我们尝试访问数组中索引为5的元素，而实际数组只有3个元素，因此会抛出一个数组越界异常（ArrayIndexOutOfBoundsException）。通过try-catch块捕获该异常，并输出错误信息。

异常的抛出和捕获机制使得程序能够在出现异常情况时进行适当的处理，避免程序崩溃或产生不可预测的结果。通过合理地抛出和处理异常，可以增加程序的可靠性和健壮性。

3.2 异常的捕获与处理

异常声明throws

在Java中，使用throws关键字可以在方法声明中指定该方法可能抛出的异常类型。通过使用throws关键字，方法可以将异常的处理责任委托给调用者，而不是在方法内部处理异常。

以下是异常声明throws的示例：

public class Example { public static void main(String[] args) { try { readFile("file.txt"); // 调用自定义方法 } catch (FileNotFoundException e) { System.out.println("文件未找到：" + e.getMessage()); } } public static void readFile(String filename) throws FileNotFoundException { // 尝试打开文件 // 如果文件不存在，将抛出FileNotFoundException异常 FileInputStream fis = new FileInputStream(filename); // 其他处理逻辑... } }

在上面的示例中，readFile()方法用于读取指定文件的内容。由于打开文件可能出现文件不存在的情况，因此在方法声明中使用了throws FileNotFoundException来指定该方法可能抛出的异常类型。这样，调用者在调用readFile()方法时，必须处理或继续向上抛出该异常。

在main()方法中，我们调用了readFile()方法，并使用try-catch块来捕获可能抛出的FileNotFoundException异常。如果捕获到异常，将会输出相应的错误信息。

需要注意的是，如果一个方法声明了抛出异常，但在方法内部没有实际抛出该异常，编译器会报错。因此，在使用throws关键字声明异常时，需要确保方法内部的代码可能会抛出相应的异常。

通过使用throws关键字声明异常，可以将异常处理的责任从方法内部转移到调用者处，使得代码更加清晰和模块化。同时，它也提供了更大的灵活性，允许在调用链中的合适位置进行异常处理。

try-catch捕获并处理

在Java中，可以使用try-catch语句块来捕获和处理异常。try-catch语句块允许我们在执行可能引发异常的代码时，捕获并处理异常，从而防止程序终止或产生不可预测的结果。

以下是try-catch捕获和处理异常的示例：

public class Example { public static void main(String[] args) { try { int result = divide(10, 0); // 调用自定义方法 System.out.println("结果：" + result); } catch (ArithmeticException e) { System.out.println("发生了算术异常：" + e.getMessage()); } } public static int divide(int num1, int num2) { try { return num1 / num2; } catch (ArithmeticException e) { throw new ArithmeticException("除数不能为零"); // 抛出算术异常 } } }

在上面的示例中，divide()方法用于计算两个数的除法操作。在方法内部，我们使用了try-catch语句块来捕获可能发生的算术异常。如果除数为零，将抛出一个算术异常（ArithmeticException）。在main()方法中，我们调用了divide()方法，并使用try-catch块捕获可能抛出的算术异常。如果捕获到异常，将会输出相应的错误信息。

需要注意的是，当异常被捕获时，程序将跳转到匹配的catch块，并执行其中的代码。在catch块中，我们可以根据异常的类型执行相应的操作，例如输出错误信息、记录日志或进行其他处理逻辑。

通过使用try-catch语句块，我们可以在程序中有选择地捕获和处理异常，从而保证程序的正常执行。这种异常处理机制使得代码更加健壮，能够在面对异常情况时进行适当的处理和恢复，避免程序崩溃或产生不可预测的结果。

finally代码块

在Java中，finally代码块用于定义无论是否发生异常都会被执行的代码。无论是在异常被捕获和处理后，还是在异常未被捕获时，finally代码块中的代码都会被执行。finally代码块通常用于释放资源或执行必要的清理操作。

下面是使用Scanner的示例，演示了finally代码块的使用：

import java.util.Scanner; public class Example { public static void main(String[] args) { Scanner scanner = null; try { scanner = new Scanner(System.in); System.out.print("请输入一个整数: "); int num = scanner.nextInt(); System.out.println("输入的整数是: " + num); } catch (Exception e) { System.out.println("发生了异常: " + e.getMessage()); } finally { if (scanner != null) { scanner.close(); // 释放资源 } } } }

在上面的示例中，我们使用了Scanner类来读取用户的输入整数。在try块中，我们创建了一个Scanner对象并读取用户的输入。如果在输入过程中发生异常，将会被捕获并输出相应的错误信息。

不管是否发生异常，finally代码块中的代码都会执行。在这个示例中，我们在finally块中检查Scanner对象是否为空，如果不为空，则调用close()方法来释放资源。

通过使用finally代码块，我们可以确保无论发生什么情况，资源都能得到正确地释放。这在需要处理资源（如文件、网络连接等）的情况下非常重要，以防止资源泄漏和程序不稳定性。

需要注意的是，finally代码块并不是必需的，可以选择省略。但是，如果使用了finally代码块，它将始终执行，无论是否发生异常。

3.3 异常的处理流程

异常的处理流程可以概括为以下几个步骤：

执行可能引发异常的代码块。这部分代码通常被包裹在try块中。
当在try块中发生异常时，程序会立即跳转到与异常类型匹配的catch块。catch块用于捕获和处理特定类型的异常。
在匹配的catch块中，根据异常的类型执行相应的操作，例如输出错误消息、记录日志或采取其他处理措施。多个catch块可以按照顺序排列，以处理不同类型的异常。
如果没有匹配的catch块或异常在catch块中未被处理，异常将被传递给上一级调用栈，继续寻找异常处理代码。
如果在当前方法中没有合适的异常处理代码，异常将继续向上层调用栈传递，直到找到能够处理异常的地方。
如果在调用栈中找到能够处理异常的catch块，相应的异常处理代码将被执行。
在异常处理完成后，程序将继续执行try-catch结构之后的代码。
如果存在finally代码块，不论异常是否发生，finally中的代码都会被执行。finally代码块通常用于释放资源、进行清理操作或确保一些必要的代码逻辑得以执行。

通过这样的异常处理流程，可以捕获和处理异常，避免程序的意外终止，并进行适当的错误处理。异常处理使得代码具备了更好的健壮性和容错性，可以保证程序在异常情况下的正常运行，并提供相应的错误信息和处理机制。

四、自定义异常类

4.1 自定义异常类的规则

在Java中，可以通过创建自定义异常类来表示和处理特定的异常情况。以下是关于自定义异常类的一些规则：

自定义异常类应继承自Exception类或其子类。通常，如果自定义异常类表示非检查异常，则可以继承RuntimeException类或其子类。
自定义异常类应提供适当的构造方法。通常，至少应包含一个带有异常信息的构造方法，以便在抛出异常时传递详细信息。可以根据需要添加其他构造方法，以便传递更多的异常信息和原因。
自定义异常类可以添加自定义的方法和逻辑，以满足特定需求。例如，可以添加用于获取特定信息的方法或执行特定操作的方法。
自定义异常类的命名应具有描述性，并遵循Java的命名约定。通常，类名以Exception结尾是一种常见的命名约定，例如MyCustomException。
自定义异常类可以根据特定的异常情况进行层次化。您可以创建自定义异常类的层次结构，通过继承关系来表示不同级别或类型的异常。这有助于更好地组织和处理不同类型的异常。

以下是一个示例，展示了一个自定义异常类的规则和示例代码：

public class MyCustomException extends Exception { public MyCustomException() { super(); } public MyCustomException(String message) { super(message); } public MyCustomException(String message, Throwable cause) { super(message, cause); } public MyCustomException(Throwable cause) { super(cause); } // 可以添加自定义的方法和逻辑 }

在上述示例中，创建了一个名为MyCustomException的自定义异常类。该类继承自Exception类，并提供了多个构造方法，以便在抛出异常时传递不同的异常信息和原因。

4.2 自定义异常案例

这里实现一个用户登陆功能，在登录的时候对用户名和密码进行校验，登录和校验的逻辑如下：

public class Login { private String userName = "admin"; private String password = "123456"; public void loginInfo(String userName, String password) { try{ if (!this.userName.equals(userName)) { throw new UserNameErrorException("用户名错误！"); // System.out.println("用户名错误！"); // return; } if (!this.password.equals(password)) { throw new PasswordException("密码错误！"); // System.out.println("密码错误！"); // return; } System.out.println("登陆成功"); } catch (UserNameErrorException | PasswordException e){ e.printStackTrace(); } } public static void main(String[] args) { Login login = new Login(); login.loginInfo("admin", "123456"); } }

在上述代码中，Login类包含了一个名为loginInfo的方法，该方法接受用户名和密码作为参数。在方法中，我们使用try-catch块来捕获可能抛出的UserNameErrorException和PasswordException异常。

在try块中，我们检查输入的用户名和密码是否与预定义的用户名和密码匹配。如果不匹配，我们抛出相应的异常，即UserNameErrorException或PasswordException。如果用户名和密码都正确，将输出"登录成功"。

在catch块中，我们捕获并处理可能抛出的异常。通过调用printStackTrace()方法，异常的堆栈跟踪信息将被打印出来，以便进行错误排查和调试。

在main方法中，创建一个Login对象并调用loginInfo方法来进行登录测试。在本例中，我们传递了正确的用户名和密码，因此输出将是"登录成功"。如果用户名或密码错误，将在控制台上打印异常的堆栈跟踪信息。

自定义异常类PasswordException和UserNameErrorException：

public class PasswordException extends RuntimeException{ public PasswordException(){ super(); } public PasswordException(String message){ super(message); } } public class UserNameErrorException extends RuntimeException{ public UserNameErrorException(){ super(); } public UserNameErrorException(String message){ super(message); } }

在上述代码中，PasswordException和UserNameErrorException类都继承自RuntimeException类，因此它们都是非检查异常。

这两个异常类提供了两个构造方法：