登神长阶 第五阶 认识异常
🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀
目录
🛠️一.异常的概念与体系结构
🗡️1.异常的概念
🪃2.异常的体系结构
🪃3.异常的分类
🏹二. 异常的处理
🛡️1.常用的处理方式
🪚2.异常的抛出
🔧3.异常的捕获
🪛4.finally
🔩三.异常的处理流程
⚙️四.自定义异常类
♨️五.总结与反思
🛠️一.异常的概念与体系结构
🗡️1.异常的概念
在Java中，异常是指程序执行过程中发生的问题或错误。当某个代码块无法正常执行时，会抛出一个异常。这可能是由于输入错误、资源不足、网络连接问题或其他原因导致的。在Java中，异常被表示为对象，它们都是Throwable类的子类。常见的异常类型包括Checked异常（需要明确捕获或声明）和Unchecked异常（编译器不要求处理的异常）。处理异常可以通过try-catch语句块来捕获和处理异常，也可以通过throws关键字将异常向上传递给调用者。Java还提供了一些内置的异常类，同时也允许开发者自定义异常类来处理特定的错误情况。
部分异常举例
算术异常
System.out.println(10 / 0);
// 执行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero数组越界异常
int[] arr = {1, 2, 3};
System.out.println(arr[100]);
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100空指针异常
int[] arr = null;
System.out.println(arr.length);
// 执行结果
Exception in thread "main" java.lang.NullPointerException从上述过程中可以看到，java中不同类型的异常，都有与其对应的类来进行描述。
🪃2.异常的体系结构
异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：
从上图中可以看到：
- Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
- Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError和OutOfMemoryError，一旦发生回力乏术。
- Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。
🪃3.异常的分类
异常可能在编译时发生，也可能在程序运行时发生，根据发生的时机不同，可以将异常分为：
1. 编译时异常
在程序编译期间发生的异常，称为编译时异常，也称为受检查异常(Checked Exception）
public class Person {
private String name;
private String gender;
int age;
// 想要让该类支持深拷贝，覆写Object类的clone方法即可
@Override
public Person clone() {
return (Person)super.clone();
}
}
编译时报错：
Error:(17, 35) java: 未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出2. 运行时异常 在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常(Unchecked Exception) RunTimeException以及其子类对应的异常，都称为运行时异常。比如：NullPointerException、 ArrayIndexOutOfBoundsException、ArithmeticException。
注意：编译时出现的语法性错误，不能称之为异常。例如将 System.out.println 拼写错了, 写成了 system.out.println. 此时编译过程中就会出错, 这是 “编译期” 出错。而运行时指的是程序已经编译通过得到class 文件了, 再由 JVM 执行过程中出现的错误.
🏹二. 异常的处理
🛡️1.常用的处理方式
在Java中，异常处理通常通过以下方式来实现：
1.使用try-catch块：可以使用try语句块捕获可能抛出异常的代码，并在catch块中处理异常。示例代码如下：
try {
// 可能会抛出异常的代码
// 比如调用可能会抛出异常的方法
} catch (Exception e) {
// 处理异常的代码
// 可以打印错误信息或者进行其他操作
}
2.throws关键字：在方法声明时使用throws关键字声明可能会抛出的异常，然后在调用该方法的地方处理异常。示例代码如下：
public void doSomething() throws SomeException {
// 可能会抛出SomeException异常的代码
}
// 在调用doSomething方法的地方处理异常
try {
doSomething();
} catch (SomeException e) {
// 处理异常的代码
}
3.finally块：finally块中的代码总是会执行，无论try块中是否有异常抛出，用于处理资源清理等操作。
try {
// 可能会抛出异常的代码
} catch (Exception e) {
// 处理异常的代码
} finally {
// 无论是否有异常都会执行的代码，比如资源释放
}🪚2.异常的抛出
在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：
throw new XXXException("异常产生的原因");【注意事项】 1. throw必须写在方法体内部 2. 抛出的对象必须是Exception 或者 Exception 的子类对象 3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理 4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译 5. 异常一旦抛出，其后的代码就不会执行
🔧3.异常的捕获
异常的捕获，也就是具体处理方式，主要有两种：异常声明throws 以及 try-catch捕获处理。
异常声明throws
处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。
语法格式：
修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
}【注意事项】 1. throws必须跟在方法的参数列表之后 2. 声明的异常必须是 Exception 或者 Exception 的子类 3. 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型 具有父子关系，直接声明父类即可。
public class Config {
File file;
// public void OpenConfig(String filename) throws IOException,FileNotFoundException{
// FileNotFoundException 继承自 IOException
public void OpenConfig(String filename) throws IOException{
if(filename.endsWith(".ini")){
throw new IOException("文件不是.ini文件");
}
if(filename.equals("config.ini")){
throw new FileNotFoundException("配置文件名字不对");
}
// 打开文件
}
public void readConfig(){
}
}4. 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出
public static void main(String[] args) throws IOException {
Config config = new Config();
config.openConfig("config.ini");
}try-catch捕获并处理 throws对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要try-catch。
语法格式：
try{
// 将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
// 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类时，就会被捕获到
// 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
}[catch(异常类型 e){
// 对异常进行处理
}finally{
// 此处代码一定会被执行到
}]
// 后序代码
// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行
注意：
1. []中表示可选项，可以添加，也可以不用添加
2. try中的代码可能会抛出异常，也可能不会关于异常的处理方式 异常的种类有很多, 我们要根据不同的业务场景来决定. 对于比较严重的问题(例如和算钱相关的场景), 应该让程序直接崩溃, 防止造成更严重的后果 对于不太严重的问题(大多数场景), 可以记录错误日志, 并通过监控报警程序及时通知程序猿 对于可能会恢复的问题(和网络相关的场景), 可以尝试进行重试. 在我们当前的代码中采取的是经过简化的第二种方式. 我们记录的错误日志是出现异常的方法调用信息, 能很 快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息.
【注意事项】 1. try块内抛出异常位置之后的代码将不会被执行 2. 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序—-异常是按照类型来捕获的
public static void main(String[] args) {
try {
int[] array = {1,2,3};
System.out.println(array[3]); // 此处会抛出数组越界异常
}catch (NullPointerException e){ // 捕获时候捕获的是空指针异常--真正的异常无法被捕获到
e.printStackTrace();
}
System.out.println("后序代码");
}
/* Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at day20210917.ArrayOperator.main(ArrayOperator.java:24)*/3. try中可能会抛出多个不同的异常对象，则必须用多个catch
public static void main(String[] args) {
int[] arr = {1, 2, 3};
try {
System.out.println("before");
// arr = null;
System.out.println(arr[100]);
System.out.println("after");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("这是个数组下标越界异常");
e.printStackTrace();
} catch (NullPointerException e) {
System.out.println("这是个空指针异常");
e.printStackTrace();
}
System.out.println("after try catch");
}如果多个异常的处理方式是完全相同, 也可以写成这样：
catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
...
}如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误：
public static void main(String[] args) {
int[] arr = {1, 2, 3};
try {
System.out.println("before");
arr = null;
System.out.println(arr[100]);
System.out.println("after");
} catch (Exception e) { // Exception可以捕获到所有异常
e.printStackTrace();
}catch (NullPointerException e){ // 永远都捕获执行到
e.printStackTrace();
}
System.out.println("after try catch");
}
Error:(33, 10) java: 已捕获到异常错误java.lang.NullPointerException
4. 可以通过一个catch捕获所有的异常，即多个异常，一次捕获(不推荐)
public static void main(String[] args) {
int[] arr = {1, 2, 3};
try {
System.out.println("before");
arr = null;
System.out.println(arr[100]);
System.out.println("after");
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("after try catch");
}
🪛4.finally
在 Java 中，finally 是一个关键字，用于定义在异常处理结构中的一个代码块。finally 块通常用于执行一些无论是否发生异常都需要被执行的清理工作。
当 try 块中的代码抛出异常时，程序会跳转到与之对应的 catch 块，如果有的话。而无论是否有异常抛出，finally 块中的代码总是会被执行。
以下是 finally 块的几个使用场景和特点：
-
资源释放：finaly 块通常用于释放系统资源，比如关闭文件、数据库连接或网络连接等。即使在发生异常的情况下，资源也能得到正确地释放。
-
清理工作：
finally块可以用于执行一些清理工作，例如清理临时变量、恢复状态等，以确保程序在任何情况下都处于一个良好的状态。 -
异常处理：
finally块中的代码在发生异常时也会被执行，这使得程序可以更好地处理异常情况，保持一致性和可靠性。
【注意事项】：
-
如果
try块中有return语句，则finally块的代码会在return语句执行之后、返回之前被执行。（不推荐） -
如果
finally块中的代码执行过程中抛出了异常，那么这个异常会覆盖try或catch块中抛出的原异常，并成为最终的异常。
总之，finally 块为处理资源释放和清理工作提供了一种强大的机制，在编写健壮的异常处理代码时起着重要的作用。
public static void main(String[] args) {
try{
int[] arr = {1,2,3};
arr[100] = 10;
arr[0] = 10;
}catch (ArrayIndexOutOfBoundsException e){
System.out.println(e);
}finally {
System.out.println("finally中的代码一定会执行");
}
System.out.println("如果没有抛出异常，或者异常被处理了，try-catch后的代码也会执行");
}
import java.io.*;
public class FinallyExample {
public static void main(String[] args) {
BufferedReader br = null;
try {
// 尝试打开文件并读取数据
br = new BufferedReader(new FileReader("example.txt"));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
// 读取完成后关闭文件
} catch (FileNotFoundException e) {
// 处理文件未找到异常
System.err.println("File not found: " + e.getMessage());
} catch (IOException e) {
// 处理其他 IO 异常
System.err.println("IO Exception: " + e.getMessage());
} finally {
// 无论是否发生异常，最终都会执行这里的代码
try {
if (br != null) {
br.close(); // 关闭文件
}
} catch (IOException e) {
System.err.println("Error while closing the file: " + e.getMessage());
}
}
}
}
在上面的示例中，我们尝试打开一个文件并从中读取数据。在 try 块内的代码尝试打开文件并读取数据，如果遇到文件未找到或其他 IO 异常，则会分别被 catch 块捕获并处理。无论是否发生异常，finally 块中的代码都会被执行，用于关闭文件并释放资源。即使在文件读取过程中发生异常，文件仍然会被关闭，确保资源得到正确释放。这个示例展示了 finally 块的作用，不管是否发生异常，我们都可以在 finally 块中执行一些必要的清理工作，以确保程序状态的一致性和资源的正确释放。
🔩三.异常的处理流程
关于 “调用栈” 方法之间是存在相互调用关系的, 这种调用关系我们可以用 “调用栈” 来描述. 在 JVM 中有一块内存空间称为 “虚拟机栈” 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用 e.printStackTrace(); 的方式查看出现异常代码的调用栈.
如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递
public class StageTest {
public static void main(String[] args) {
try {
func();
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}
System.out.println("after try catch");
}
public static void func() {
int[] arr = {1, 2, 3};
System.out.println(arr[100]);
}
// 直接结果
/*java.lang.ArrayIndexOutOfBoundsException: 100
at demo02.Test.func(Test.java:18)
at demo02.Test.main(Test.java:9)
after try catch*/如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止(和我们最开始未使用 try catch 时是一样的).
public class StageTest {
public static void main(String[] args) {
func();
System.out.println("after try catch");
}
public static void func() {
int[] arr = {1, 2, 3};
System.out.println(arr[100]);
}
// 执行结果
/* Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at demo02.Test.func(Test.java:14)
at demo02.Test.main(Test.java:8)*/
可以看到, 程序已经异常终止了, 没有执行到 System.out.println(“after try catch”); 这一行. 【异常处理流程总结】
- 程序先执行 try 中的代码
- 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
- 如果找到匹配的异常类型, 就会执行 catch 中的代码
- 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
- 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
- 如果上层调用者也没有处理的了异常, 就继续向上传递.
- 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.
⚙️四.自定义异常类
Java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构.
在 Java 中，自定义异常类是用户根据特定需求创建的异常类，通常通过继承 Exception 类或其子类来实现。以下是详细描述 Java 中自定义异常类的步骤和使用方法：
1.创建自定义异常类：
- 自定义异常类通常需要提供构造方法和一些额外的属性或方法以满足具体的异常情况。
- 自定义异常类可以直接继承自
Exception类或其子类，例如RuntimeException、IOException等。
public class CustomException extends Exception {
public CustomException() {
super();
}
public CustomException(String message) {
super(message);
}
// 可以定义额外的构造方法、属性或方法
}
2.抛出自定义异常：
在代码中遇到特定的业务逻辑错误或异常情况时，可以通过创建自定义异常对象并抛出来进行处理。
public class Example {
public void doSomething(int value) throws CustomException {
if (value < 0) {
throw new CustomException("Value cannot be negative");
}
// 其他代码逻辑
}
}
3.捕获自定义异常：
当调用可能会抛出自定义异常的方法时，需要在调用处使用 try-catch 块捕获该异常。
public class Main {
public static void main(String[] args) {
Example example = new Example();
try {
example.doSomething(-1);
} catch (CustomException e) {
System.out.println("Caught custom exception: " + e.getMessage());
}
}
}
4.使用自定义异常类：
- 自定义异常类通常通过构造方法传入异常消息，以便在捕获异常时提供相关信息。
- 可以根据业务需求在自定义异常类中添加其他属性和方法，以更好地描述异常情况和处理逻辑。
通过自定义异常类，可以更好地组织和管理异常情况，使代码结构更清晰，并确保程序在发生特定异常时能够采取正确的处理方式。
例如：我们实现一个用户登录功能
class UserNameException extends Exception {
public UserNameException(String message) {
super(message);
}
}
class PasswordException extends Exception {
public PasswordException(String message) {
super(message);
}
}public class LogIn {
private String userName = "admin";
private String password = "123456";
public static void loginInfo(String userName, String password)
throws UserNameException,PasswordException{
if (!userName.equals(userName)) {
throw new UserNameException("用户名错误！");
}
if (!password.equals(password)) {
throw new PasswordException("用户名错误！");
}
System.out.println("登陆成功");
}
public static void main(String[] args) {
try {
loginInfo("admin", "123456");
} catch (UserNameException e) {
e.printStackTrace();
} catch (PasswordException e) {
e.printStackTrace();
}
}
}注意事项
- 自定义异常通常会继承自 Exception 或者 RuntimeException
- 继承自 Exception 的异常默认是受查异常
- 继承自 RuntimeException 的异常默认是非受查异常
♨️五.总结与反思
💡现实是此岸，理想是彼岸，中间隔着湍急的河流，行动则是架在河上的桥梁。——克雷洛夫
在实际项目中，异常处理是不可避免的一部分，需要结合具体业务场景，灵活运用异常处理机制，确保程序的稳定性和可维护性。不断总结和反思异常处理中遇到的问题和经验，及时修正和优化异常处理代码，以提高代码质量和开发效率。
通过学习和实践 Java 中的异常处理，我深刻认识到异常处理不仅是代码中的一部分，更是一种思维方式，一种面对问题和挑战的态度。只有不断学习和积累经验，才能更好地应对程序中可能出现的异常情况，写出更加稳健和可靠的 Java 程序。
🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀
以上，就是本期的全部内容啦，若有错误疏忽希望各位大佬及时指出💐
制作不易，希望能对各位提供微小的帮助，可否留下你免费的赞呢🌸
版权声明：本文为博主作者：中草药z原创文章，版权归属原作者，如果侵权，请联系我们删除！
原文链接：https://blog.csdn.net/2302_79806056/article/details/136805195
