当前位置: 首页 > news >正文

【从零开始学习JAVA | 第三十二篇】 异常(下)新手必学!

目录

前言:

 Exceptions(异常):

异常的两大作用:

异常的处理方式:

1.JVM默认处理

 2.自己捕获异常

3.抛出处理

自定义异常:

异常的优点:

总结:


前言:

        前文我们详细的为大家介绍了整个异常体系的框架,本篇我们将为大家介绍Exceptions异常,我们会讲解他的作用以及如何捕获,这一篇很重要!!在搭建后端以及与前端交互的时候是一个很好用的技能,因此我们即使不看本篇文章,也一定要自己积极主动了解相关内容!!

 Exceptions(异常):

在Java中,异常(Exceptions)也是一种处理程序运行期间错误或异常情况的机制。异常是通过Java中的类来表示的,这些类被称为异常类(Exception Classes)。

Java中的异常机制是基于“抛出和捕获”的原则。当程序出现异常的时候,异常被创建并抛出(throw),然后在代码的其他地方被捕获(catch),并执行相应的处理逻辑。

Java中的异常类是从 `java.lang.Exception` 类派生出来的。异常类分为两类:检查异常(Checked Exceptions)和非检查异常(Unchecked Exceptions)。

1. 检查异常:

  •     检查异常是指在代码中可能出现的特定情况,需要显式处理。
  •     检查异常必须在方法的声明中声明或者在方法体内通过try-catch语句块捕获。
  •     例如:IOException、FileNotFoundException等。

2. 非检查异常:

  •     非检查异常是指程序在运行时可能出现的异常情况。
  •     非检查异常通常是由程序错误导致的,如数组越界、除零错误等。
  •     非检查异常无需在方法声明或方法体内捕获,但可以选择捕获并进行处理。
  •     例如:NullPointerException、ArithmeticException等。

Java提供了多个关键字和语句来处理异常,其中包括:

  •  try-catch语句用于捕获并处理异常。
  •  throws关键字用于声明可能抛出的异常类型。
  •  finally块用于定义无论是否出现异常都需要执行的代码。
  •  throw关键字用于手动抛出异常。

通过合理地处理异常,可以提高Java程序的健壮性和可靠性,确保程序在异常情况下仍能正常运行。

异常的两大作用:

1.异常是用来查询bug的关键参考信息。

假设你编写了一个处理用户登录的程序,其中包括一个用户验证的功能。如果用户提供的用户名不存在,你可能会抛出一个"UserNotFoundException"的异常。这个异常将包含有关错误的关键信息,如用户名,以便于在处理异常时进行调试和修复bug。

例如:

public class UserLogin {public void validateUser(String username, String password) throws UserNotFoundException {// 在数据库中查找用户if (!userExists(username)) {throw new UserNotFoundException("用户名不存在:" + username);}// 进行密码验证等其他操作// ...}private boolean userExists(String username) {// 查询数据库,判断用户是否存在// ...}// 其他代码
}

在上面的例子中,如果用户提供的用户名在数据库中不存在,该程序将抛出一个"UserNotFoundException"异常,并传递包含错误信息的字符串。通过查看异常信息,你可以追踪到出错的位置,并在必要时修复bug,例如检查数据库查询逻辑等。异常信息对于开发人员来说是非常有用的,因为它们提供了有关bug发生位置和原因的重要线索。而我们以前还需要利用print手动输出一个“密码不存在”。

那为什么不选择打印报错呢?

这是因为抛出异常是一种更为灵活和规范的做法。它提供了一种统一的异常处理机制,使得调用者可以根据需要捕获和处理异常,而不仅仅是简单地打印错误信息。异常还可以传递更详细的错误信息和上下文,方便调用者进行更高级的错误处理逻辑。打印错误信息虽然简单直接,但对于复杂的程序和错误处理需求来说可能不够灵活和可扩展。而且异常抛出之后,程序就会直接停止执行,而我们的print打印报错对于编译器来讲只是正常的执行了一条打印语句,仍然会继续进行,需要我们自己手动停止。

2.异常可以作为方法内部的一种特殊返回值,用来告知调用者底层的执行情况。

public class FileProcessor {public void processFile(String fileName) throws FileProcessingException {try {// 打开文件,进行处理openFile(fileName);// 其他处理逻辑// ...// 关闭文件closeFile();} catch (IOException e) {// 处理文件操作异常throw new FileProcessingException("文件处理发生异常", e);}}private void openFile(String fileName) throws IOException {// 打开文件的逻辑// ...}private void closeFile() throws IOException {// 关闭文件的逻辑// ...}
}

在上面的例子中,FileProcessor类的processFile方法用于处理指定文件。如果在处理文件的过程中发生文件操作异常(如文件无法打开、读取或关闭等),它将抛出一个FileProcessingException异常,并将底层的IOException作为原因传递给调用者。

通过这种方式,调用者可以捕获并处理异常,进一步了解底层执行情况,比如是否成功打开和关闭文件。异常提供了一种机制,允许将错误信息从方法的实现细节传递到方法的调用方,使得调用者可以根据需要采取适当的措施。

异常作为方法内部的特殊返回值其作为查询bug的关键参考信息之间的区别主要在于目的和使用方式。它们都提供了有关底层执行情况的信息,在方法内部作为返回值时,异常用于传达执行状态;而在查询bug时,异常信息用于诊断和调试错误的代码。

异常的处理方式:

1.JVM默认处理

JVM默认的处理方式就是把异常的名称,异常原因,以及异常出现的位置等信息输出在控制台。而程序此时也会停止执行,不会再进行下面的语句。

例如直接执行这段代码:

public class test10 {public static void main(String[] args) {int[] arr = new int[3];System.out.println(arr[4]); // 数组越界异常}
}

 控制台就会输出:

 2.自己捕获异常

我们自己捕获异常就是利用try和catch语句,自定义异常语句以及出现异常之后的执行策略。

格式为:

try{
可能出现异常的代码;
}
catch{
异常的处理代码
}

目的:当代码出现异常的时候,可以让程序继续往下执行。并不会像JVM默认处理的时候那样,直接停止程序。

public class test10 {public static void main(String[] args) {try {int result = divide(10, 0); // 调用自定义的除法方法System.out.println("结果:" + result);} catch (ArithmeticException e) { // 捕获特定类型的异常System.out.println("除数不能为零!");e.printStackTrace(); // 打印堆栈跟踪}System.out.println("我可以被执行!");}public static int divide(int dividend, int divisor) {return dividend / divisor; // 可能引发除零异常的除法操作}
}

执行结果为:

 try捕捉异常的三种情况:

  • 每个异常被不同的 catch 块捕获和处理:在 try 块中的每个可能抛出异常的语句都有对应的 catch 块来捕获和处理该异常。这样可以根据不同的异常类型执行适当的处理逻辑。
try {// 可能抛出异常的语句1// 可能抛出异常的语句2// ...
} catch (ExceptionType1 e1) {// 处理异常类型1
} catch (ExceptionType2 e2) {// 处理异常类型2
} catch (ExceptionType3 e3) {// 处理异常类型3
}
  • 多个异常被同一个 catch 块捕获和处理:如果多个异常属于同一个异常类型的子类型,可以使用同一个 catch 块捕获和处理它们。这种情况下,可以通过异常对象的属性或方法来区分和处理不同的子类型异常。
try {// 可能抛出异常的语句1// 可能抛出异常的语句2// ...
} catch (ParentExceptionType e) {// 处理多个异常类型
}
  • 异常被上层的 catch 块捕获:如果在 try 块中的某个 catch 块成功捕获了一个异常,且没有在其中抛出新的异常,那么该异常会被视为已被处理,并不会传递到下一个 catch 块。
try {// 可能抛出异常的语句1// 可能抛出异常的语句2// ...
} catch (ExceptionType1 e1) {// 处理异常类型1,并不再传递异常
} catch (ExceptionType2 e2) {// 处理异常类型2
}
  • 如果我们tyr中的异常没有被捕获(例如抛出了数组越界异常,但是我们只写了判断空指针异常,此时的异常就没有被catch捕获),那么我们就会执行JVM的默认处理方式。

捕捉异常的注意点:

                1.如果我们要捕捉多个异常,且这些异常中存在父子关系,那么父类一定要在最下面

这么写是catch匹配异常是从上往下进行匹配的,而父类异常可以接受所有的子类异常,这就导致所有的异常走到父类异常这里都会被接受,而后面的子类异常接收不到任何异常,导致子类异常被父类异常接受,可能无法得到我们想要的结果,因此我们要把父类异常放到子类异常的最下面。

如果你想捕获所有可能抛出的异常,可以使用Exception类作为catch块的参数。这样可以捕获到所有派生自Exception的异常。

try {// 可能抛出异常的语句
} catch (Exception e) {// 处理异常
}

如果你想捕获特定类型的异常,可以使用该异常类或其子类作为catch块的参数。

try {// 可能抛出异常的语句
} catch (ArithmeticException e) {// 处理算术异常
} catch (NullPointerException e) {// 处理空指针异常
} catch (IOException e) {// 处理输入输出异常
}catch (Exception e) {// 处理异常
}

通过掌握父类和子类之间的关系,可以更有效地处理不同类型的异常,并为程序提供适当的错误处理机制。

        2.try中只要产生了一个异常,try的剩下部分就会被跳过,因此我们不可以在一个try中写多个异常语句,这是没有用的,只会执行第一个异常,而我们写这么多的catch,意义在于针对这一个异常,我们要针对性的捕获它!

public class test10 {public static void main(String[] args) {try {int[] numbers = {1, 2, 3};System.out.println(numbers[4]); // 数组越界异常int result = divide(10, 0); // 除零异常System.out.println("结果:" + result);} catch (ArrayIndexOutOfBoundsException e) {System.out.println("捕获到数组越界异常!");e.printStackTrace();} catch (ArithmeticException e) {System.out.println("捕获到除零异常!");e.printStackTrace();} catch (Exception e) {System.out.println("捕获到其他异常!");e.printStackTrace();}System.out.println("异常处理完成!");}public static int divide(int dividend, int divisor) {return dividend / divisor;}
}

执行结果:

 我们可以看到除零异常根本不会被捕获,因为第一个数组越界异常发生以后,try语句中的所有剩余都会被跳过。

手动捕获异常处理中的常见方法:

Throwable 是Java中所有异常类的根类,它定义了一些常用的方法,可以在异常处理中使用。下面是一些常用的 Throwable 方法:

  • getMessage():返回异常的详细描述信息。
try {// 可能抛出异常的代码
} catch (Exception e) {System.out.println(e.getMessage()); // 打印异常信息
}
  • printStackTrace():将异常的跟踪栈信息输出到标准错误流(System.err),可以用于调试和定位异常发生的位置。
try {// 可能抛出异常的代码
} catch (Exception e) {e.printStackTrace(); // 输出异常跟踪栈信息
}
  • getCause():返回导致当前异常的原因异常,通常用于嵌套异常场景。
try {// 可能抛出异常的代码
} catch (Exception e) {Throwable cause = e.getCause();if (cause != null) {System.out.println("导致异常的原因:" + cause.getMessage());}
}
  • getLocalizedMessage():返回异常本地化描述信息,如果该异常类提供了本地化描述,则返回本地化描述信息,否则返回异常描述信息。
try {// 可能抛出异常的代码
} catch (Exception e) {System.out.println(e.getLocalizedMessage()); // 打印异常的本地化描述信息
}
  • toString():返回异常的字符串表示,包括异常类名和详细描述信息。
try {// 可能抛出异常的代码
} catch (Exception e) {System.out.println(e.toString()); // 打印异常的字符串表示
}

这些是 Throwable 类的一些常用方法。需要注意的是,Throwable 还有其他的方法和一些子类的特定方法,可以根据需要进一步了解和使用。

3.抛出处理

 throws:

throws 关键字用于在方法声明中指定该方法可能抛出的异常类型。通过使用 throws 关键字,可以将异常传递给调用者或上层代码来处理,而不是在方法内部进行捕获和处理。

下面是一个使用 throws 的简单例子:

import java.io.FileNotFoundException;
import java.io.FileReader;public class FileProcessor {public static void main(String[] args) {try {readFile("file.txt");} catch (FileNotFoundException e) {System.out.println("文件不存在!");e.printStackTrace();}}public static void readFile(String fileName) throws FileNotFoundException {FileReader fileReader = new FileReader(fileName);// 进行文件读取操作// ...}
}

在上述代码中,我们有一个 readFile 方法,用于从指定的文件中读取内容。由于读取文件可能会发生文件不存在的异常,因此在方法声明中使用 throws 关键字指定了可能抛出的 FileNotFoundException 异常。

在 main 方法中调用 readFile("file.txt") 时,如果文件不存在,将会抛出 FileNotFoundException 异常。由于我们使用了 throws 来声明可能抛出的异常,因此需要通过在 main 方法中使用 catch 块来捕获并处理该异常。

通过使用 throws,我们可以将异常的处理责任交给调用者或上层代码,从而使代码更加模块化和灵活。调用者可以选择捕获并处理异常,或继续向上层代码传递异常,直到有相应的异常处理机制为止。

throw:

throw 关键字用于手动抛出一个异常。它可以用于任何地方,包括方法、构造函数、代码块和其他异常处理机制中。通过使用 throw 关键字,可以在程序中指示错误或异常情况,并将控制权交给上层代码或异常处理机制来处理。

抛出异常的一般语法如下:

throw throwableObject;

其中,throwableObject 是要抛出的异常对象,可以是 Java 内置的异常类(如 RuntimeExceptionIOException 等)或自定义的异常类的实例。

以下是一个使用 throw 抛出异常的例子:

public class AgeValidation {public static void main(String[] args) {try {int age = -5;validateAge(age);} catch (IllegalArgumentException e) {System.out.println("年龄无效!");e.printStackTrace();}}public static void validateAge(int age) {if (age < 0) {throw new IllegalArgumentException("年龄不能为负数!");}System.out.println("年龄有效!");}
}

在上述代码中,我们有一个 validateAge 方法,它接收一个年龄作为参数,并通过判断年龄是否为负数来验证年龄的有效性。如果年龄为负数,则使用 throw 关键字手动抛出一个 IllegalArgumentException 异常,并提供错误消息 “年龄不能为负数!”。

在 main 方法中调用 validateAge(-5) 时,传入了一个负数作为年龄,触发了异常的抛出。然后,在 catch 块中捕获并处理该异常。

通过使用 throw,我们可以在需要的时候手动抛出异常,以便在程序中指示错误或异常情况,并将异常控制权交给上层代码或异常处理机制。这有助于提高程序的可读性和可维护性,并实现更精确的异常处理。

throw与throws的区别:

throw 和 throws 是在异常处理中使用的关键字,它们有以下差别:

  1. 功能不同:

    • throw 用于主动抛出异常。它可以在任何地方使用,用于手动抛出一个异常对象。
    • throws 用于在方法声明中指定该方法可能抛出的异常类型。它用于向调用者或上层代码声明当前方法可能会抛出的异常,以便调用者能够适当地处理异常。
  2. 使用位置不同:

    • throw 关键字可以用于方法、构造函数、代码块或其他异常处理机制内部的任何位置。
    • throws 关键字只能在方法或构造函数的声明部分使用,用于指定该方法可能抛出的异常。
  3. 异常处理责任不同:

    • 使用 throw 抛出异常后,控制权会立即转移到调用栈中的适当的异常处理机制,如 try-catch 块。
    • 使用 throws 声明异常后,方法仍然可以继续执行,并将异常的处理责任交给调用该方法的代码。

综上所述,throw 用于手动抛出异常,而 throws 用于在方法声明中指定可能抛出的异常类型。throw 直接触发异常并将控制权转移给异常处理机制,而 throws 声明异常后,方法仍然会执行,将异常抛给调用者处理。

自定义异常:

在Java中,可以通过创建自定义异常类来实现用户定义的异常。自定义异常类可以根据特定的业务需求或异常情况,提供更具体、更清晰的异常信息,并允许开发者以自定义的方式处理异常

创建自定义异常类的步骤如下:

  1. 创建一个继承自 Exception 或其子类的类,并命名为你想要的异常类名。

  2. 在自定义异常类中,可以添加自定义的构造方法和其他方法,用于初始化异常对象和提供额外的异常信息。

  3. 可以选择重写父类的方法,或添加自定义的方法来满足特定的需求。例如,可以添加方法来获取更详细的异常信息。

下面是一个简单的自定义异常类的例子:

public class InvalidAgeException extends Exception {private int age;public InvalidAgeException(int age) {super("年龄不合法!");this.age = age;}public int getAge() {return age;}
}

在上述代码中,我们创建了一个自定义的异常类 InvalidAgeException,它继承自 Exception 类。该异常类具有一个带有参数的构造方法,用于初始化异常对象,并提供年龄信息。我们还添加了一个 getAge 方法,用于获取年龄信息。

使用自定义异常类时,可以在代码中以相同的方式处理它们,就像处理内置的异常类一样。例如,可以使用 try-catch 块来捕获和处理自定义异常。

以下是一个使用自定义异常的示例:

public class AgeValidation {public static void main(String[] args) {try {int age = -5;validateAge(age);} catch (InvalidAgeException e) {System.out.println("年龄无效!年龄为:" + e.getAge());e.printStackTrace();}}public static void validateAge(int age) throws InvalidAgeException {if (age < 0) {throw new InvalidAgeException(age);}System.out.println("年龄有效!");}
}

在上述代码中,我们使用自定义异常类 InvalidAgeException 来实现对年龄的验证。当年龄为负数时,我们使用 throw 关键字抛出 InvalidAgeException 异常,并将年龄作为参数传递给异常构造方法。在 main 方法中,通过 try-catch 块捕获并处理该异常。

自定义异常类的使用可以提供更具体和详细的异常信息,使异常处理更精确和可控。它可以让开发者根据特定的业务需求创建和处理异常,从而提高程序的可读性和可维护性。

异常的优点:

1. 异常处理机制:异常提供了一种结构化的错误处理机制,使开发者能够更容易地检测、捕获和处理错误。通过合理使用异常处理,可以提高代码的可维护性和可读性。

2. 分离正常流程和异常处理逻辑:异常机制将正常的业务逻辑与异常处理逻辑分离开来。这样,在编写代码时,可以将主要注意力放在正常情况下的逻辑流程上,而将异常情况作为特殊情况进行处理。

3. 提供错误信息和堆栈追踪:异常对象中包含有关错误的详细信息,例如异常类型、错误消息和堆栈追踪。这些信息能够帮助开发者快速定位和解决问题,缩短调试时间。

4. 异常传播和处理:异常机制允许异常在调用栈中传播,直到被捕获并处理。这意味着一个方法中的异常可以由该方法的调用者捕获和处理,使得异常的处理可以在不同的层次上进行。

5. 提高代码可靠性和稳定性:通过捕获和处理异常,可以防止程序因遇到错误而崩溃或产生不可预测的行为。合理处理异常可以增强代码的健壮性,使程序更可靠和稳定。

6. 资源释放:异常处理机制还可以确保在异常情况下正确释放和关闭系统资源,避免资源泄露和其他问题。

总结:

        本文我们为大家详细的介绍了关于异常的知识点,异常的使用可以让我们提高对代码的掌控能力,异常就像手术刀一样,可以精准的切割我们的bug部分,使我们快速的对代码进行修改,异常是一种强大的错误处理工具,可以帮助开发者优雅地处理异常情况,提高代码的可靠性和可维护性。合理地使用异常处理机制可以改善程序的质量,提高开发效率。

如果我的内容对你有帮助,请点赞,评论,收藏。创作不易,大家的支持就是我坚持下去的动力!

 

http://www.lryc.cn/news/97790.html

相关文章:

  • onnxruntime (C++/CUDA) 编译安装
  • 第三篇-Tesla P40+CentOS-7+CUDA 11.7 部署实践
  • Unity游戏源码分享-ARPG游戏Darklight.rar
  • 类型转换运算符
  • Kafka 入门到起飞系列 - 消费者组管理、位移管理
  • SpringBoot——数据层三组件之间的关系
  • LeetCode647.Palindromic-Substrings<回文子串>
  • React的hooks---useContext
  • 【Terraform学习】TerraformCloud入门介绍(快速入门)
  • linux实现运行java分包部署
  • 数据安全之全景图系列——数据分类分级落地实践
  • C++实现MySQL数据库连接池
  • day4 驱动开发 c语言学习
  • history命令:显示命令执行时间
  • Django接口返回JSON格式数据报文
  • OBS 迁移--华为云
  • 【Docker consul的容器服务更新与发现】
  • MFC第二十天 数值型关联变量 和单选按钮与复选框的开发应用
  • 服务器 Docker Alist挂载到本地磁盘(Mac版)夸克网盘
  • EMP-SSL: TOWARDS SELF-SUPERVISED LEARNING IN ONETRAINING EPOCH
  • 注解和反射01--什么是注解
  • 虚拟机 RHEL8 安装 MySQL 8.0.34
  • kafka 总结宝典
  • 跨平台力量:探索C++Qt框架的未来前景
  • 基于长短期神经网络LSTM的位移监测,基于长短期神经网络的位移预测,LSTM的详细原理
  • ChatGPT漫谈(二)
  • 【LangChain】检索器之MultiQueryRetriever
  • 教师ChatGPT的23种用法
  • 【libevent】http客户端1:转存http下载的数据
  • Pytorch学习笔记 | 数据类型 | mnist数据集