详解Java中的异常体系结构(throw,throws,try-catch,finally,自定义异常)

简介: 详解Java中的异常体系结构(throw,throws,try-catch,finally,自定义异常)

一.异常的概念

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

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

     

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


二.异常的体系结构

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



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


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

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


三.异常的处理

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


异常处理思路

LBYL:Look Before You Leap

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

        boolean ret = false;
        ret = loginGame();
        if (!ret) {
            //处理登陆游戏错误;
            return;
        }
        ret = startMatch();
        if (!ret) {
            //处理匹配错误;
            return;
        }
        ret = conGame();
        if (!ret) {
            //处理游戏确认错误;
            return;
        }
        ret = choiceChar();
        if (!ret) {
            //处理选择英雄错误;
            return;
        }
        ret = loading();
        if (!ret) {
            //处理载入游戏错误;
            return;
        }

   

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


EAFP: It's Easier to Ask Forgiveness than Permission

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

        try {
            loginGame();
            startMatch();
            conGame();
            choiceChar();
            loading();
        } catch (loginGame异常) {
            //处理登陆游戏错误;
        } catch (startMatch异常) {
            //处理匹配错误;
        } catch (conGame异常) {
            //处理游戏确认错误;
        } catch (choiceChar异常) {
            //处理选择英雄错误;
        } catch (loading异常) {
            //处理载入游戏错误;
        }

   


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


  • throw
  • try
  • catch
  • final
  • throws

异常抛出throw

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


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


示例:

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

 

注意:


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

异常的捕获

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


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

提醒声明throws

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

语法格式:


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


}

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


注意事项:


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

示例:

class Config {
    File file;
    // 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(){
    }
    public void openConfig(String s) {
    }
    public static void main(String[] args) throws IOException {
        Config config = new Config();
        config.openConfig("config.ini");
    }
}



try-catch捕获处理

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


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

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


示例:

class Config {
    File file;
    public void openConfig(String filename) throws FileNotFoundException{
        if(!filename.equals("config.ini")){
            throw new FileNotFoundException("配置文件名字不对");
        }
        // 打开文件
    }
    public void readConfig(){
    }
    public static void main(String[] args) {
        Config config = new Config();
        try {
            config.openConfig("config.txt");
            System.out.println("文件打开成功");
        } catch (IOException e) {
        // 异常的处理方式
        //System.out.println(e.getMessage()); // 只打印异常信息
        //System.out.println(e); // 打印异常类型:异常信息
            e.printStackTrace(); // 打印信息最全面
        }
        // 一旦异常被捕获处理了,此处的代码会执行
        System.out.println("异常如果被处理了,这里的代码也可以执行");
    }
}


注意:


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

finally的作用

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


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


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

四.自定义异常类

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

  1. 继承自 Exception 的异常默认是受查异常
  2. 继承自 RunTimeException 的异常默认是非受查异常

具体方式:


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

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

class UserNameException extends Exception {
    public UserNameException(String message) {
        super(message);
    }
}
class PasswordException extends Exception {
    public PasswordException(String message) {
        super(message);
    }
}
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();
        }
    }
}



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


目录
相关文章
|
1月前
|
Java
在 Java 中捕获和处理自定义异常的代码示例
本文提供了一个 Java 代码示例,展示了如何捕获和处理自定义异常。通过创建自定义异常类并使用 try-catch 语句,可以更灵活地处理程序中的错误情况。
66 1
|
1月前
|
Java API 调度
如何避免 Java 中的 TimeoutException 异常
在Java中,`TimeoutException`通常发生在执行操作超过预设时间时。要避免此异常,可以优化代码逻辑,减少不必要的等待;合理设置超时时间,确保其足够完成正常操作;使用异步处理或线程池管理任务,提高程序响应性。
73 12
|
1月前
|
Java
在 Java 中,如何自定义`NumberFormatException`异常
在Java中,自定义`NumberFormatException`异常可以通过继承`IllegalArgumentException`类并重写其构造方法来实现。自定义异常类可以添加额外的错误信息或行为,以便更精确地处理特定的数字格式转换错误。
39 1
|
17天前
|
Java
java实现从HDFS上下载文件及文件夹的功能,以流形式输出,便于用户自定义保存任何路径下
java实现从HDFS上下载文件及文件夹的功能,以流形式输出,便于用户自定义保存任何路径下
80 34
|
1月前
|
IDE 前端开发 Java
怎样避免 Java 中的 NoSuchFieldError 异常
在Java中避免NoSuchFieldError异常的关键在于确保类路径下没有不同版本的类文件冲突,避免反射时使用不存在的字段,以及确保所有依赖库版本兼容。编译和运行时使用的类版本应保持一致。
73 7
|
1月前
|
Java 编译器
如何避免在 Java 中出现 NoSuchElementException 异常
在Java中,`NoSuchElementException`通常发生在使用迭代器、枚举或流等遍历集合时,尝试访问不存在的元素。为了避免该异常,可以在访问前检查是否有下一个元素(如使用`hasNext()`方法),或者使用`Optional`类处理可能为空的情况。正确管理集合边界和条件判断是关键。
80 6
|
1月前
|
Java 开发者 Spring
[Java]自定义注解
本文介绍了Java中的四个元注解(@Target、@Retention、@Documented、@Inherited)及其使用方法,并详细讲解了自定义注解的定义和使用细节。文章还提到了Spring框架中的@AliasFor注解,通过示例帮助读者更好地理解和应用这些注解。文中强调了注解的生命周期、继承性和文档化特性,适合初学者和进阶开发者参考。
62 14
|
1月前
|
Java
Java异常捕捉处理和错误处理
Java异常捕捉处理和错误处理
68 1
|
1月前
|
Java 编译器 开发者
Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面,帮助开发者提高代码质量和程序的健壮性。
76 2
|
1月前
|
Java
如何在 Java 中处理“Broken Pipe”异常
在Java中处理“Broken Pipe”异常,通常发生在网络通信中,如Socket编程时。该异常表示写入操作的另一端已关闭连接。解决方法包括:检查网络连接、设置超时、使用try-catch捕获异常并进行重试或关闭资源。
117 5