您现在的位置是：首页 > 技术教程 正文

详解Java中的异常体系结构（throw，throws，try-catch，finally，自定义异常）

admin 阅读： 2024-03-23
后台-插件-广告管理-内容页头部广告（手机）

目录

一.异常的概念

二.异常的体系结构

三.异常的处理

异常处理思路

LBYL：Look Before You Leap

EAFP: It's Easier to Ask Forgiveness than Permission

异常抛出throw

异常的捕获

提醒声明throws

 try-catch捕获处理

finally的作用

四.自定义异常类

一.异常的概念

有一句话说的很好 ”程序员不是在写BUG就是在改BUG” ，在日常开发中，程序员绞尽脑汁的去写出完美的代码，但是在程序运行过程中难免回遇见一些奇奇怪怪的问题。而这些问题与BUG总是很难去控制，用人类的思维去看明明是很完美的一个逻辑处理，但是交给编译器就产生的结果总会与我们的预期大相径庭，在Java中，我们将程序执行过程中发生的不正常的行为称为异常，比如什么算数异常啊，数组越界异常啊，空指针异常啊这都属于异常的范围，我们统称为异常

  1. System.out.println(10 / 0);
  2. // 执行结果Exception in thread "main" java.lang.ArithmeticException
  4. int[] arr1 = {1, 2, 3};
  5. System.out.println(arr1[100]);
  6. // 执行结果Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
  8. int[] arr2 = null;
  9. System.out.println(arr2.length);
  10. // 执行结果Exception in thread "main" java.lang.NullPointerException

并且我们可以看见在Java中对于不同的异常，都有对应的类来描述

二.异常的体系结构

实际上异常的种类是很多的，为了应对不同的异常或者错误，Java提供了一个非常庞大的异常体系机构供程序员来更好的维护代码的安全性，如下图所示

异常可能发生在编译阶段，可能发生在运行阶段，因此我们可以按照异常发生的时间段将其进行分类：

  • 编译时异常，也叫做受查异常
  • 运行时异常，也叫做非受查异常 

但是诸如将单词拼写错误导致的问题我们程序出现问题的情况不属于异常

三.异常的处理

代码中存在异常并不是什么奇怪的事情，但是在出现异常后，我们需要及时通知程序员去修改，对于异常的处理，我们分为俩种思路

异常处理思路

LBYL：Look Before You Leap

也就是说我们在操作之前就对异常做出充分的检查，也就是事先防御型，比如我们在设计一款游戏的时候，我们就需要对其中可能发生的每一个错误做出处理机制和避免机制

  1. boolean ret = false;
  2. ret = loginGame();
  3. if (!ret) {
  4. //处理登陆游戏错误;
  5. return;
  6. }
  7. ret = startMatch();
  8. if (!ret) {
  9. //处理匹配错误;
  10. return;
  11. }
  12. ret = conGame();
  13. if (!ret) {
  14. //处理游戏确认错误;
  15. return;
  16. }
  17. ret = choiceChar();
  18. if (!ret) {
  19. //处理选择英雄错误;
  20. return;
  21. }
  22. ret = loading();
  23. if (!ret) {
  24. //处理载入游戏错误;
  25. return;
  26. }

但这样的处理会有一个缺陷：正常流程和错误处理流程代码混在一起, 代码整体显的比较混乱

EAFP: It's Easier to Ask Forgiveness than Permission

这样的思想主要解决的问题不是如何提前避免异常，而是在异常出现以后如何进行合理的应对

  1. try {
  2. loginGame();
  3. startMatch();
  4. conGame();
  5. choiceChar();
  6. loading();
  8. } catch (loginGame异常) {
  9. //处理登陆游戏错误;
  10. } catch (startMatch异常) {
  11. //处理匹配错误;
  12. } catch (conGame异常) {
  13. //处理游戏确认错误;
  14. } catch (choiceChar异常) {
  15. //处理选择英雄错误;
  16. } catch (loading异常) {
  17. //处理载入游戏错误;
  18. }

在Java中对于异常处理的核心机制就是EAFP，Java中常用的有5个异常处理的关键字：

  • throw
  • try
  • catch
  • final
  • throws

异常抛出throw

在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

throw new XXXException ("异常产生的原因");

示例： 

  1. public static int getElement(int[] array, int index){
  2. if(null == array){
  3. throw new NullPointerException("传递的数组为null");
  4. }
  5. if(index < 0 || index >= array.length){
  6. throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
  7. }
  8. return array[index];
  9. }
  10. public static void main(String[] args) {
  11. int[] array = {1, 2, 3};
  12. getElement(array, 3);
  13. }

 注意：

  1. throw 必须写在方法体内部
  2. 抛出的对象必须是Exception 或者 Exception 的子类对象
  3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
  4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
  5. 异常一旦抛出，其后的代码就不会执行

异常的捕获

异常的捕获就是指我们对异常的处理，通常我们有俩种方式去处理：

  • 异常声明throws
  • try-catch捕获处理

提醒声明throws

处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者来处理。也就是说当前方法不处理异常，提醒方法的调用者处理异常。

语法格式：

修饰符 返回值类型 方法名 (参数列表) throws 异常类型1，异常类型2...{

}

  1. public class Config {
  2. File file;
  3. /*
  4. FileNotFoundException : 编译时异常，表明文件不存在
  5. 此处不处理，也没有能力处理，应该将错误信息报告给调用者，让调用者检查文件名字是否给错误了
  6. */
  7. public void OpenConfig(String filename) throws FileNotFoundException {
  8. if (filename.equals("config.ini")) {
  9. throw new FileNotFoundException("配置文件名字不对");
  10. }
  11. // 打开文件
  12. }
  13. }

注意事项：

  • throws 必须跟在方法参数列表之后
  • 抛出的问题必须是Exception 或者 Exception 的子类对象
  • 方法内部如果抛出了多个异常，throws 之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可
  • 调用声明抛出的异常方法时，调用者必须对异常做出处理，或者继续使用throws 抛出

示例： 

  1. class Config {
  2. File file;
  3. // FileNotFoundException 继承自 IOException
  4. public void OpenConfig(String filename) throws IOException {
  5. if(filename.endsWith(".ini")){
  6. throw new IOException("文件不是.ini文件");
  7. }
  8. if(filename.equals("config.ini")){
  9. throw new FileNotFoundException("配置文件名字不对");
  10. }
  11. // 打开文件
  12. }
  13. public void readConfig(){
  14. }
  15. public void openConfig(String s) {
  16. }
  17. public static void main(String[] args) throws IOException {
  18. Config config = new Config();
  19. config.openConfig("config.ini");
  20. }
  21. }

 try-catch捕获处理

刚才我们提到的throws 并没有对异常做出处理，他只是将异常报给调用者，让调用者去处理，而如果要对异常真正的处理就需要使用try-catch。

try-catch的一般使用语法如下，其中catch：可以有一个也可以有多个，根据具体需求分配，finally可以有也可以没有，但是如果有的话finally中的代码就一定会执行，并且try中的代码也可以不出现异常：

  1. try{
  2. // 将可能出现异常的代码放在这里
  3. }catch(要捕获的异常类型 e){
  4. // 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时
  5. //或者是try中抛出异常的基类时，就会被捕获到
  6. //对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
  7. }catch(异常类型 e){
  8. // 对异常进行处理
  9. }finally{
  10. // 此处代码一定会被执行到
  11. }
  12. }

示例：

  1. class Config {
  2. File file;
  3. public void openConfig(String filename) throws FileNotFoundException{
  4. if(!filename.equals("config.ini")){
  5. throw new FileNotFoundException("配置文件名字不对");
  6. }
  7. // 打开文件
  8. }
  9. public void readConfig(){
  10. }
  11. public static void main(String[] args) {
  12. Config config = new Config();
  13. try {
  14. config.openConfig("config.txt");
  15. System.out.println("文件打开成功");
  16. } catch (IOException e) {
  17. // 异常的处理方式
  18. //System.out.println(e.getMessage()); // 只打印异常信息
  19. //System.out.println(e); // 打印异常类型：异常信息
  20. e.printStackTrace(); // 打印信息最全面
  21. }
  22. // 一旦异常被捕获处理了，此处的代码会执行
  23. System.out.println("异常如果被处理了，这里的代码也可以执行");
  24. }
  25. }

注意：

  •  try 块内抛出异常位置之后的代码将不会被执行
  •  如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的
  •  try 中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获
  • 如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误

finally的作用

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

关于异常的处理方式，异常的种类有很多，我们要根据不同的业务场景来决定

  • 对于比较严重的问题(例如和算钱相关的场景), 应该让程序直接崩溃, 防止造成更严重的后果
  • 对于不太严重的问题(大多数场景), 可以记录错误日志, 并通过监控报警程序及时通知程序猿
  • 对于可能会恢复的问题(和网络相关的场景), 可以尝试进行重试
  • 在我们当前的代码中采取的是经过简化的第二种方式. 我们记录的错误日志是出现异常的方法调用信息, 能很快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息

四.自定义异常类

Java中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构，自定义异常通常会继承自 Exception或RunTimeException

  • 继承自 Exception 的异常默认是受查异常
  • 继承自 RunTimeException 的异常默认是非受查异常

具体方式：

  1. 自定义异常类，然后继承自Exception 或者 RunTimeException
  2. 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因

例如我们实现一个用户登陆功能： 

  1. class UserNameException extends Exception {
  2. public UserNameException(String message) {
  3. super(message);
  4. }
  5. }
  6. class PasswordException extends Exception {
  7. public PasswordException(String message) {
  8. super(message);
  9. }
  10. }
  1. class LogIn {
  2. private String userName = "admin";
  3. private String password = "123456";
  4. public static void loginInfo(String userName, String password)
  5. throws UserNameException,PasswordException{
  6. if (!userName.equals(userName)) {
  7. throw new UserNameException("用户名错误！");
  8. }
  9. if (!password.equals(password)) {
  10. throw new PasswordException("用户名错误！");
  11. }
  12. System.out.println("登陆成功");
  13. }
  14. public static void main(String[] args) {
  15. try {
  16. loginInfo("admin", "123456");
  17. } catch (UserNameException e) {
  18. e.printStackTrace();
  19. } catch (PasswordException e) {
  20. e.printStackTrace();
  21. }
  22. }
  23. }

 本次的分享就到此为止了，希望我的分享能给您带来帮助，也欢迎大家三连支持，你们的点赞就是博主更新最大的动力！如有不同意见，欢迎评论区积极讨论交流，让我们一起学习进步！有相关问题也可以私信博主，评论区和私信都会认真查看的，我们下次再见

标签:
声明

1.本站遵循行业规范，任何转载的稿件都会明确标注作者和来源；2.本站的原创文章，请转载时务必注明文章作者和来源，不尊重原创的行为我们将追究责任；3.作者投稿可能会经我们编辑修改或补充。

在线投稿：投稿 站长QQ：1888636

后台-插件-广告管理-内容页尾部广告（手机）
相关文章
关注我们

扫一扫关注我们，了解最新精彩内容

搜索
排行榜
最近发表
标签列表