【JAVA】认识异常

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量885 收藏 13
点赞数 31
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_star_galaxy/article/details/139150489
版权

        这就是JAVA初阶的最后一讲了，关于异常的一系列问题。

1. 异常的概念与体系结构

1.1 异常的概念

在Java中，将程序执行过程中发生的不正常行为称为异常。比如之前写代码时经常遇到的：

1. 算术异常

System.out.println(10 / 0);


// 执行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero

2. 数组越界异常

int[] arr = {1, 2, 3};
System.out.println(arr[100]);


// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

3. 空指针异常

int[] arr = null;
System.out.println(arr.length);


// 执行结果
Exception in thread "main" java.lang.NullPointerException

从上述过程中可以看到，java中不同类型的异常，都有与其对应的类来进行描述。

1.2 异常的体系结构

        异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构。

  1. Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
  2. Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError和OutOfMemoryError，一旦发生回力乏术。
  3. Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。

1.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 执行过程中出现的错误.

2. 异常的处理

2.1 防御式编程

        错误在代码中是客观存在的. 因此我们要让程序出现问题的时候及时通知程序猿. 主要的方式        

        1. LBYL: Look Before You Leap. 在操作之前就做充分的检查. 即：事前防御型

boolean ret = false;
ret = 登陆游戏();
if (!ret) {
    处理登陆游戏错误;
    return;
}
 
ret = 开始匹配();
if (!ret) {
    处理匹配错误;
    return;
} 

ret = 游戏确认();
if (!ret) {
    处理游戏确认错误;
    return;
}
 
ret = 选择英雄();
if (!ret) {
    处理选择英雄错误;
    return;
}
 
ret = 载入游戏画面();
if (!ret) {
    处理载入游戏错误;
    return;
}

缺陷：正常流程和错误处理流程代码混在一起, 代码整体显的比较混乱。

2. EAFP: It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到问题再处理. 即：事后认错型

try {
    登陆游戏();
    开始匹配();
    游戏确认();
    选择英雄();
    载入游戏画面();
    ...
} catch (登陆游戏异常) {
    处理登陆游戏异常;
} catch (开始匹配异常) {
    处理开始匹配异常;
} catch (游戏确认异常) {
    处理游戏确认异常;
} catch (选择英雄异常) {
    处理选择英雄异常;
} catch (载入游戏画面异常) {
    处理载入游戏画面异常;
}

优势：正常流程和错误流程是分离开的, 程序员更关注正常流程，代码更清晰，容易理解代码异常处理的核心思想就是 EAFP。

在Java中，异常处理主要的5个关键字：throw、try、catch、final、throws。

2.2 异常的抛出

在编写程序时，如果程序中出现错误，此时就需要将错误的信息告知给调用者，比如：参数检测。

在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. 异常一旦抛出，其后的代码就不会执行

2.3 异常的捕获

异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws 以及 try-catch捕获处理。

2.3.1 异常声明throws

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

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

}

需求：加载指定的配置文件config.ini
 

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

    }
}

【注意事项】

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");
}

2.3.2 try-catch捕获并处理

        throws对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要try-catch。

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


// 后序代码
// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行


注意：
1. []中表示可选项，可以添加，也可以不用添加
2. try中的代码可能会抛出异常，也可能不会

需求：读取配置文件，如果配置文件名字不是指定名字，抛出异常，调用者进行异常处理
 

public 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("异常如果被处理了，这里的代码也可以执行");
    }
}

关于异常的处理方式

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

【注意事项】

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");
}

由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常.

备注: catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 也会捕捉目标异常类型的子类对象.如刚才的代码, NullPointerException 和 ArrayIndexOutOfBoundsException 都是 Exception 的子类,因此都能被捕获到.

2.3.3 finally

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

语法格式：
try{
    // 可能会发生异常的代码
}catch(异常类型 e){
    // 对捕获到的异常进行处理
}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后的代码也会执行");
}

finally 执行的时机是在方法返回之前(try 或者 catch 中如果有 return 会在这个 return 之前执行 finally). 但是如果finally 中也存在 return 语句, 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的 return.

        这就是关于异常处理相关内容，也是JAVA初阶的一个结束，后面我们还会继续更新新的内容，大家关注，保留期待。

Mr_star_galaxy
关注
  • 31
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
有效的Java异常
02-04
本文认为错误并不在于Java模型本身，而在于Java库设计人员没有认识到方法失败的两个基本原因。本文提倡思考异常情况的本质，并描述了有助于用户设计的设计模式。最后，本文讨论了异常处理在面向方面编程...
高效Java异常处理机制
03-04
本文认为错误并不在于Java模型本身，而在于Java库设计人员没有认识到方法失败的两个基本原因。本文提倡思考异常情况的本质，并描述了有助于用户设计的设计模式。最后，本文讨论了异常处理在面向方面编程...
Java 认识异常
2302_79806056的博客
03-19 1651
通过学习和实践 Java 中的异常处理，我深刻认识到异常处理不仅是代码中的一部分，更是一种思维方式，一种面对问题和挑战的态度。
Java认识异常
qq_57241128的博客
12-04 962
1. 异常的背景 初识异常 我们曾经的代码中已经接触了一些 "异常" 了. 例如：
java认识异常
2401_84815407的博客
05-12 779
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Java认识异常（超级详细）
asdssadddd的博客
09-09 1383
举个例子：实现一个获取数组中任意位置元素的方法。注意事项1.throw必须写在方法体内部2.抛出的对象必须是Exception或者Exception的子类对象3.如果抛出的是RunTimeException或者RunTimeException的子类，则可以不用处理，可以交给JVM来处理4.如果抛出的是编译时异常，用户必须处理，否则无法通过编译5.异常一旦抛出，其后的代码就不会执行异常的捕获。
Java——认识异常
qq_63492484的博客
05-03 1685
Java异常的超强详解！！！
Java 认识异常（模拟王者登录异常）
爱干饭的猿的博客
01-22 666
异常的基本语法：（模拟王者登录游戏的执行过程）
Java 异常处理详解
兴趣是最好的老师，勤能补拙
05-13 2708
Java 异常处理机制是 Java 编程中至关重要的一部分。一个好的 Java 程序应该能够正确地处理异常，避免异常泄露到用户界面，保证程序的健壮性和稳定性。在 Java 开发过程中，需要充分认识和了解异常处理的相关知识和技巧，并且在编写代码时合理地使用异常处理机制。
认识JAVA中的异常
robin_suli的博客
06-01 1654
程序中存在未释放的内存资源，导致内存占用不断增加，最终导致内存不足等等。，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果抛出的是编译时异常，用户必须处理，否则无法通过编译。真正要对异常进行处理，就需要try-catch。如果抛出的是 RunTimeException。但是并不能完全表示实际开发中所遇到的一些异常。是异常体系的顶层类，其派生出两个重要的子类。如图：这里还用了，try处理catch捕捉。用好他们就，可以很好的处理异常了。，抛出一个指定的异常对象，将。中虽然已经内置了丰富的异常类。
Java---认识异常
2302_80826557的博客
06-14 1167
首先会执行try代码块里面的代码，看其是否抛出异常。如果抛出异常，就会看catch代码块有没有匹配的异常，如果catch边没有找到对应的异常，就会交给上层调用者去处理。如果上层调用者也没有处理异常，则会交给main方法处理，如果main方法也没有处理，则最后就会交给JVM去处理。虽然在Java中，异常的种类也很丰富了，但终会有一些异常在Java中是没有定义的，所以我们要学会自定义异常类。1. 自定义异常一般都会继承Exception类或者RunTimeException类。
java异常常见面试题（全）
码农研究僧的博客
01-29 3278
目录前言finally在什么时候执行finally一定会被执行吗 前言 对于异常的详细知识点可看我之前的文章 javaSE从入门到精通的二十万字总结（一） 以及对异常机制的科普补充 java异常处理机制 finally在什么时候执行 无论出现什么情况，finally代码块的内容都会执行（除非碰到了exit函数才会退出） 即使try中有return的语句，finally的return语句都会把try中的return语句覆盖了 finally一定会被执行吗 答案是不是，有两种情况finally会不执行 进行tr
11.认识异常1
08-03
在Java中，异常处理是通过异常类来实现的，这些异常类构成了Java异常体系。异常的发生通常分为编译期错误和运行时错误。编译期错误在代码编写阶段就能被检测出来，如语法错误、类型不匹配等；而运行时错误则是在程序...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 310
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1091
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 144
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 589
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 346
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 713
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java语言入门教程：从认识Java到GUI编程
“此资源是一份详细的Java基础课件，涵盖了从认识Java到深入的面向对象编程、异常处理、集合、GUI编程、文件I/O、多线程和网络编程等多个核心主题。课程旨在介绍Java语言的基本概念、发展历史、版本变迁以及应用领域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mr_star_galaxy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值