Java认识异常

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

目录标题

异常的概念与体系结构

异常的概念

异常（Exception它是指由于程序运行中发生了某些不可预料或不可避免的问题而造成的错误或异常情况。通俗的讲，异常就是程序在运行过程中出现的意外状况。

比如我们在编写代码时常遇到的异常(java中不同类型的异常，都有与其对应的类来进行描述):

//1.算数异常
System.out.println(10/0);
//Exception in thread "main" java.lang.ArithmeticException: / by zero

//数组越界异常
int[] arr = {1, 2, 3};
System.out.println(arr[4]);
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

//空指针异常
 int[] arr = null;
 System.out.println(arr.length);
//Exception in thread "main" java.lang.NullPointerException

异常的体系结构

在这里插入图片描述

  1. Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
    2.Error 是致命错误，无法被程序处理，通常需要修复程序代码,比如：JVM的内部错误、资源耗尽等，比如：StackOverflowError和OutOfMenoryError
  2. Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。

异常的分类

1. 编译时异常
在程序编译期间发生的异常，称为编译时异常，也称为受检查异常(Checked Exception)，编译不能通过，需要处理

class Person implements Cloneable {
//重写克隆接口
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        //向下转型
        Person person1 =(Person)person.clone();
    }
}
//未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出

2.运行时异常
在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常(Unchecked Exception)RunTimeException以及其子类对应的异常，都称为运行时异常。 比如ArithmeticException(算数异常)、ArrayIndexOutOfBoundsException(数组越界异常)、NullPointerException(空指针异常)

异常的处理方式

防御式编程

  1. LBYL: Look Before You Leap. 在操作之前就做充分的检查. 即：事前防御型
public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int index = 6;
        if (index < 0 || index >= args.length) {
            System.out.println("索引越界");
            return ;//结束当前方法的执行
        }
    }
}
//我们先判断索引是否越界，再执行数组元素的访问操作。通过事前进行判断，避免了程序在运行时抛出 ArrayIndexOutOfBoundsException异常

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

  1. EAFP: It’s Easier to Ask Forgiveness than Permission. “事后获取原谅比事前获取许可更容易”. 也就是先操作, 遇到问题再处理. 即：事后认错型
public class Test {
    public static void main(String[] args) {
        int dividend = 20;
        int divisor = 0;
        int quotient = 0;
        try {
            quotient = dividend / divisor; // 会抛出ArithmeticException异常
        } catch (ArithmeticException e) {
            System.err.println("除数不能为0");
        }
        System.out.println("商：" + quotient);
    }
}
//除数不能为0
//商：0

优势:正常流程和错误流程是分离开的，容易理解代码异常处理的核心思想就是EAFP。

异常的抛出

在编写程序时，如果程序中出现错误，此时就需要将错误的信息告知给调用者，比如：参数检测。
在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

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

//实现一个获取数组中任意位置元素的方法
public class Test {
    static int getElement(int[] array,int index) {
        if (array == null) {
            throw new NullPointerException();
        }
        if(index < 0 || index >= array.length){
            throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
        }
        return array[index];
    }
    public static void main(String[] args) {
        int[] array = {1,2,4};
        getElement(array,3);
    }
}
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 传递的数组下标越界
  1. throw必须写在方法体内部
  2. 抛出的对象必须是Exception或者Exception的子类对象
  3. 如果抛出的是RunTimeException或者RunTimeException的子类，则可以不用处理，直接交给JVM来处理
  4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
  5. 异常一旦抛出，其后的的代码就不会执行

异常的捕获

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

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

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

}

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

1.throw必须跟在方法的参数列表之后
2. 声明的异常必须是Exception或者Exception的子类
3. 方法的内部如果抛出了多个异常，throw之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常有父子关系，则直接声明父类即可
4. 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

将光标放在抛出异常方法上，按住Alt+Enter即可快速处理异常

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

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

public class Test {
    public static void main(String[] args) {
        System.out.println("before");
        try {
            System.out.println(10/0);
            int[] array = null;
            System.out.println(array.length);
            System.out.println("vhahuhsv");//代码不会被执行
        }
        //捕获算数异常
       catch (ArithmeticException e) {
            System.out.println("捕获到了算数异常!");
            e.printStackTrace();//将错误的信息显示哪一行出现了问题
        } catch (NullPointerException e) {
            System.out.println("捕获空指针异常");
            e.printStackTrace();
        } catch (Exception e) {//Exception可以捕获到所有的异常
            e.printStackTrace();
        }
        System.out.println("after");
    }
}
  1. try块内抛出异常位置之后的代码将不会被执行
  2. 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的
  3. try中可能会抛出多个不同的异常对象，则需要使用多个catch来捕获，即多种异常，多次捕获
    如果多个异常的处理方式时完全相同，可以写成

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
…
}

如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误
4. 可以通过一个catch捕获所有的异常，即多个异常(不推荐)，因为不知道是什么原因导致出现的异常

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

catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 也会捕捉目标异常类型的子类对象，NullPointerException 和ArrayIndexOutOfBoundsException 都是 Exception 的子类,因此都能被捕获到

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

语法格式：
try {
// 可能会发生异常的代码
} catch(异常类型 e) {
// 对捕获到的异常进行处理
} finally {
// 此处的语句无论是否发生异常，都会被执行到
}
// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

public class Test {
    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-finally后的代码都会执行，那为什么还要有finally呢？

//实现getDate方法，内部输入一个整形数字，然后将该数字返回，并再main方法中打印
public class Test {
    public static int getDate() {
        Scanner scanner = null;
        try {
            scanner = new Scanner(System.in);
            int data = scanner.nextInt();
            return data;
        } catch (InputMismatchException e) {//输入异常错误
            e.printStackTrace();
        } finally {
            System.out.println("finally中的代码");
        }
        System.out.println("try-catch-finally之后的代码");
        if (scanner != null) {
            scanner.close();//关闭资源
        }
        return 0;
    }

    public static void main(String[] args) {
        int data = getDate();
        System.out.println(data);
    }
}

如果正常输入，成功接收输入后程序就返回了，try-catch-finally之后的代码根本就没有执行，即输入流就没有释放，造成资源泄露，所以说在finally中的代码一定会执行的，一般在finally中进行一些资源清理的扫尾工作

public class Test {
    public static void main(String[] args) {
        System.out.println(func());//20
    }
    public static int func() {
        try {
            return 10;
        } finally {
            return 20;
        }
    }
}

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

throw 和 throws 的区别？
throw 是用于抛出一个特定的异常对象，它通常用在方法内部，表示方法执行过程中发生了某些错误，无法继续执行，需要将错误信息告知调用者。
throws 是用于声明方法可能抛出的异常，它通常用在方法定义时，表示可能抛出的异常类型列表。使用 throws 声明的异常，throws 后跟的是异常

异常的处理流程

关于"调用栈"
方法之间是存在相互调用关系的, 这种调用关系我们可以用 “调用栈” 来描述. 在 JVM 中有一块内存空间称为"虚拟机栈" 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用e.printStackTrace(); 的方式查看出现异常代码的调用栈.

如果本方法中没有合适的处理异常的方式，就会沿着调用栈向上传递

public class Test {
    public static void func(int a) {
        try {
            System.out.println(10/a);
        } catch (ArithmeticException e) {
            e.printStackTrace();
            System.out.println("a==0");
        }
    }
    public static void main(String[] args) {
        func(0);
    }
}
//java.lang.ArithmeticException: / by zero
//	at demo1.Test.func(Test.java:18)
//	at demo1.Test.main(Test.java:25)
//  a==0

如果向上一直传递都没有合适的方法处理异常，最终就会交给JVM处理，程序就会异常终止(和我们最开始未使用try-catch时一样的)

public class Test {
    public static void func(int a) {
            System.out.println(10/a);
    }
    public static void main(String[] args) {
        func(0);
    }
}
//Exception in thread "main" java.lang.ArithmeticException: / by zero
//	at demo1.Test.func(Test.java:17)
//	at demo1.Test.main(Test.java:20)

总结

  • 程序先执行 try 中的代码
  • 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配
  • 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配
  • 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者
  • 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行)
  • 如果上层调用者也没有处理的了异常, 就继续向上传递
  • 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止

自定义异常类

Java中已经有了非常多的异常类，但不能完全表示开发中所遇到的异常，此时就需要我们自己定义异常类

//实现一个用户登录功能
public class Test2 {
    private String userName = "admin";//用户名
    private String password = "123456";//密码
    public void logininfo(String userName,String password) {
        if (!this.userName.equals(userName)) {
            System.out.println("用户名不正确");
            return;
        } if (!this.password.equals(password)) {
            System.out.println("密码不正确");
            return;
        }
        System.out.println("登陆成功");
    }

    public static void main(String[] args) {
        Test2 test2 = new Test2();
        test2.logininfo("admin","123456");
    }
}

如果用户名或者密码错误时，就需要抛出两种异常，我们就而已基于已有的的类进行继承，创建相关的的异常

  1. 自定义异常类，然后继承自Exception(编译时异常)或者RunTimeException(运行时异常)
  2. 实现一个带有String类型参数的构造方法，参数含义:出现异常的原因
//编译时异常
//处理密码错误的异常
class PasswordExcention extends Exception{
    public PasswordExcention() {
    }
    public PasswordExcention(String message) {
        super(message);
    }
}
//处理用户名错误的异常
class UserNameExcention extends Exception{
    public UserNameExcention() {
    }
    public UserNameExcention(String message) {
        super(message);
    }
}
public class Test3 {
    private String userName = "admin";
    private String password = "123456";
    public void logininfo(String userName,String password) throws UserNameExcention,PasswordExcention{
        if (!this.userName.equals(userName)) {
            throw new UserNameExcention(userName+"用户名错误");
        } if (!this.password.equals(password)) {
            throw new PasswordExcention(password+"密码错误");
        }
        System.out.println("登陆成功");
    }

    public static void main(String[] args) {
        Test3 test3 = new Test3();
        try {
            test3.logininfo("admin","123456");
        } catch (UserNameExcention e) {
            e.printStackTrace();
        } catch (PasswordExcention e) {
            e.printStackTrace();
        }
    }
}

//运行时异常
class PasswordExcention extends RuntimeException{

}
class UserNameExcention extends RuntimeException{

}
public class Test2 {
    private String userName = "admin";
    private String password = "123456";
    public void logininfo(String userName,String password) {
        if (!this.userName.equals(userName)) {
            throw new UserNameExcention();
        } if (!this.password.equals(password)) {
            throw new PasswordExcention();
        }
        System.out.println("登陆成功");
    }
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        test2.logininfo("dmin","123456");
    }
}
  1. 自定义异常通常会继承自Exception或者RuntimeException
  2. 继承自Exception的异常默认是受查异常
  3. 继承自RuntimeException的异常默认是非受查异常
记得午睡.
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
有效的Java异常
02-04
本文认为错误并不在于Java模型本身，而在于Java库设计人员没有认识到方法失败的两个基本原因。本文提倡思考异常情况的本质，并描述了有助于用户设计的设计模式。最后，本文讨论了异常处理在面向方面编程...
高效Java异常处理机制
03-04
本文认为错误并不在于Java模型本身，而在于Java库设计人员没有认识到方法失败的两个基本原因。本文提倡思考异常情况的本质，并描述了有助于用户设计的设计模式。最后，本文讨论了异常处理在面向方面编程...
Java 认识异常
2302_79806056的博客
03-19 1632
通过学习和实践 Java 中的异常处理，我深刻认识到异常处理不仅是代码中的一部分，更是一种思维方式，一种面对问题和挑战的态度。
java认识异常
2401_84815407的博客
05-12 776
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Java认识异常（超级详细）
asdssadddd的博客
09-09 1380
举个例子：实现一个获取数组中任意位置元素的方法。注意事项1.throw必须写在方法体内部2.抛出的对象必须是Exception或者Exception的子类对象3.如果抛出的是RunTimeException或者RunTimeException的子类，则可以不用处理，可以交给JVM来处理4.如果抛出的是编译时异常，用户必须处理，否则无法通过编译5.异常一旦抛出，其后的代码就不会执行异常的捕获。
Java——认识异常
qq_63492484的博客
05-03 1680
Java异常的超强详解！！！
Java 认识异常（模拟王者登录异常）
爱干饭的猿的博客
01-22 665
异常的基本语法：（模拟王者登录游戏的执行过程）
Java 异常处理详解
兴趣是最好的老师，勤能补拙
05-13 2690
Java 异常处理机制是 Java 编程中至关重要的一部分。一个好的 Java 程序应该能够正确地处理异常，避免异常泄露到用户界面，保证程序的健壮性和稳定性。在 Java 开发过程中，需要充分认识和了解异常处理的相关知识和技巧，并且在编写代码时合理地使用异常处理机制。
认识JAVA中的异常
robin_suli的博客
06-01 1650
程序中存在未释放的内存资源，导致内存占用不断增加，最终导致内存不足等等。，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果抛出的是编译时异常，用户必须处理，否则无法通过编译。真正要对异常进行处理，就需要try-catch。如果抛出的是 RunTimeException。但是并不能完全表示实际开发中所遇到的一些异常。是异常体系的顶层类，其派生出两个重要的子类。如图：这里还用了，try处理catch捕捉。用好他们就，可以很好的处理异常了。，抛出一个指定的异常对象，将。中虽然已经内置了丰富的异常类。
java异常常见面试题（全）
码农研究僧的博客
01-29 3274
目录前言finally在什么时候执行finally一定会被执行吗 前言 对于异常的详细知识点可看我之前的文章 javaSE从入门到精通的二十万字总结（一） 以及对异常机制的科普补充 java异常处理机制 finally在什么时候执行 无论出现什么情况，finally代码块的内容都会执行（除非碰到了exit函数才会退出） 即使try中有return的语句，finally的return语句都会把try中的return语句覆盖了 finally一定会被执行吗 答案是不是，有两种情况finally会不执行 进行tr
Java---认识异常
2302_80826557的博客
06-14 1156
首先会执行try代码块里面的代码，看其是否抛出异常。如果抛出异常，就会看catch代码块有没有匹配的异常，如果catch边没有找到对应的异常，就会交给上层调用者去处理。如果上层调用者也没有处理异常，则会交给main方法处理，如果main方法也没有处理，则最后就会交给JVM去处理。虽然在Java中，异常的种类也很丰富了，但终会有一些异常在Java中是没有定义的，所以我们要学会自定义异常类。1. 自定义异常一般都会继承Exception类或者RunTimeException类。
11.认识异常1
08-03
在Java中，异常处理是通过异常类来实现的，这些异常类构成了Java异常体系。异常的发生通常分为编译期错误和运行时错误。编译期错误在代码编写阶段就能被检测出来，如语法错误、类型不匹配等；而运行时错误则是在程序...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 333
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 568
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1187
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1178
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1081
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 741
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java语言入门教程：从认识Java到GUI编程
“此资源是一份详细的Java基础课件，涵盖了从认识Java到深入的面向对象编程、异常处理、集合、GUI编程、文件I/O、多线程和网络编程等多个核心主题。课程旨在介绍Java语言的基本概念、发展历史、版本变迁以及应用领域...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值