当前位置:主页 > 查看内容

普歌-逆越团队:Java【异常】知识点详细整理

发布时间:2021-04-07 00:00| 位朋友查看

简介:Java【异常】知识点详细整理 一、含义理解 二、异常的分类所有异常都是Throwable的子类 三、异常处理的原理 四、异常处理的方式 五、重要知识点 一、含义理解 指的是【程序在执行过程中】出现的非正常的情况最终会导致【JVM的非正常停止】。 在java等面向对……

一、含义(理解)

  指的是【程序在执行过程中】,出现的非正常的情况,最终会导致【JVM的非正常停止】。
  
    在java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对象,
  java处理异常的方式是中断处理。
  
  异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行。

二、异常的分类(所有异常都是Throwable的子类)

Java程序运行过程中所发生的异常事件从严重性可分为两类:致命异常Error和非致命异常Exception。

错误(Error):JVM系统内部错误或资源耗尽等严重情况,属于JVM需要负担的责任,这一类异常事件无法恢复
            或不可能捕获,将导致应用程序中断。
            简单来说就是【程序无法处理的系统错误,编译器不做检查,只能修改程序才能修正】。
        例如:OutofMemoryError-------->内存溢出的错误,创建的数组太大了,超出了给JVM分配的内存.

异常(Exception):其它因编程错误或偶然的外在因素导致的一般性问题,这类异常得到恰当的处理时,
                程序有机会恢复至正常运行状况。 简单来说就是程序可以处理的异常,捕获后可能恢复。
                分为【编译期异常】(受检异常)(非RuntimeException)和【运行期异常】(非受检异常)(RuntimeException)

      【编译期异常】(受检异常)(非RuntimeException):1.SQLException:操作数据库异常
                                                     2.IOException:输入输出异常
                                                     3.ClassNotFoundException:指定的类不存在
                                                     4.FileNotFoundException:文件未找到异常
                                                     ......
      【运行期异常】(非受检异常)(RuntimeException):1.NullPointerException:空指针异常
                                                     2.IndexOutOfBoundsException:数组下标越界异常
                                                     3.ArrayIndexOutOfBoundsException:数组索引越界
                                                     4.NumberFormatException:字符串转换为数字异常
                                                     5.ClassCastException :数据类型转换异常
                                                     6.ArithmeticException:数学运算异常
                                                     ......

三、异常处理的原理

  • Java程序在执行过程中如果出现异常,会自动生成一个异常类对象,该异常对象将被自动提交给JVM,这个过程称为抛出(throw)异常
  • 当JVM接收到异常对象时,会寻找能处理这异常的代码。(发现异常:try)
  • 找到了,把当前异常对象交给catch处理,这一过程称为捕获(catch)异常和处理异常。(捕获异常:catch)
  • 没找到,如果JVM找不到可以捕获异常的代码,则运行时系统将终止,相应的Java程序也将退出。

四、异常处理的方式

1.处理方式1 -------> try catch (主动处理异常)
使用try…catch代码块可以捕获异常,捕获后可以继续执行后面的代码

 语法:

? try{

        存放可以出现异常的代码
    
? } catch(异常类型 e){  捕获异常

        处理异常

}  finally {

        不管是否出现异常,都会执行该代码块

 }
  • try:它后面是一个代码块,代码块里是可能发生异常的代码。

  • catch:它后面是可能发生异常的类型以及异常发生后需要做的处理

  • finally:后面是一个代码块,主要是异常发生时资源释放问题

  • catch和finally可以省略其中一个 , catch和finally不能同时省略

  • 如果 catch 中 return 了,finally 还会执行。
    原因:执行流程:

    1. 先计算返回值, 并将返回值存储起来, 等待返回
    2. 执行finally代码块
    3. 将之前存储的返回值, 返回出去;
  • 返回值是在finally运算之前就确定了,并且缓存了,不管finally对该值做任何的改变,返回的值都不
    会改变

  • finally代码中不建议包含return,因为程序会在上述的流程中提前退出,也就是说返回的值不是try或

    catch中的值

2.处理方式2 -------> throws(抛出异常)

throws关键字:异常处理的第一种方式,交给别人处理
        作用:当方法内部抛出异常对象的时候,那么就必须处理这个异常对象,可以使用throws关键字处理异常对象,
              会【把异常对象声明抛出给方法的调用者处理】(自己不处理,给别人处理),最终交给JVM处理------>中断处理。
        格式:public 返回值类型 方法名称(参数列表,,,)throws AAAException,BBBException...{
                    throw   new AAAException("产生原因");
                    throw   new BBBException("产生原因");
                     ...
                   };
        注意:
            1.throws关键字必须写在方法声明处
            2.throws关键字后边声明的异常必须是Exception或者是Exception的子类
            3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常
              如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
            4.调用了一个声明抛出异常的方法,我们就必须的处理声明的异常  
                              要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM
                              要么try…catch自己处理异常    
                              下面展示一些 `内联代码片`。
使用throws是将异常抛出,谁调用该方法,谁就去处理它。
public class Test04 {
	public static void main(String[] args) {
		try {
			method01();
		} catch (FileNotFoundException e) {
			System.out.println("处理异常");
		}
	}
	public static void method01() throws FileNotFoundException{
		method02();
	}
	public static void method02() throws FileNotFoundException{
		method03();
	}
	public static void method03() throws FileNotFoundException{
		method04();
	}
	//抛出异常,在调用方处理
	public static void method04() throws FileNotFoundException{
		File file = new File("xxx1.txt");
		FileInputStream fis = new FileInputStream(file);
	}
}

3.处理方式3 -------> throw

throw关键字作用:在指定的方法中抛出指定的异常。 
           格式: throw  new  xxxException(“异常产生的原因”);

           注意:throw关键字必须写在方法的内部
                 throw关键字后边new的对象必须是Exception或者Exception的子类对象
                 throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
                 throw关键字后边创建的是RuntimeException或者RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序 )
                 throw关键字创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch
       下面展示一些 `内联代码片`。
throw不能单独使用,只能配合throws或try{}catch{}使用。
public class Test05 {
	
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		
		//throw 抛出异常
		
		Scanner scan = new Scanner(System.in);
		
		int a = scan.nextInt();
		int b = scan.nextInt();
		
		try{
			if(b == 0){
				throw new MyException();//生成异常对象,将其抛出给JVM
			}
		}catch (MyException e) {
			b = 1;
		}
		
		System.out.println(a/b);
		scan.close();
		
	}
}
class MyException extends Exception{

	private static final long serialVersionUID = -5575465536117397751L;
	
	@Override
	public String toString() {
		return "除数不能为0的异常";
	}
	
}

五、重要知识点

1.throws和throw的区别

throws:在方法后边声明异常,其实就是自己不想对异常做出任何的处理,告诉别人自己可能出现的异常,
       交给别人处理,然别人处理

throw:就是自己处理一个异常,有两种方式要么是自己捕获异常try...catch代码块,
      要么是抛出一个异常(throws 异常)


区别:
throws:a.用来声明一个方法可能产生的所有异常,不做任何处理而是将异常往上传,谁调用我我就抛给谁。
        b.用在方法声明后面,跟的是异常类名
        c. 可以跟多个异常类名,用逗号隔开
        d. 表示抛出异常,由该方法的调用者来处理
        e.throws表示出现异常的一种可能性,并不一定会发生这些异常
        
throw: a.则是用来抛出一个具体的异常类型。
        b.用在方法体内,跟的是异常对象名
        c.只能抛出一个异常对象名
        d. 表示抛出异常,由方法体内的语句处理
        e.throw则是抛出了异常,执行throw则一定抛出了某种异常  

2.throw/throws和try/catch的区别

a."throw/throws"后面的程序不会执行,"try/catch"后面的程序还会执行;

b.throws是表明方法抛出异常,需要调用者来处理,如果不想处理就一直向外抛,最后会有jvm来处理;
  try catch 是自己来捕获别人抛出的异常,然后在catch里面去处理;

   '一般情况下,第二种情况要好一些,这样可以清楚地看到异常的原因,并加以修正。

3.try代码块:

  • try:监视代码执行过程,一旦发现异常则直接跳转至catch,如果没有catch,则直接跳转至finally。
  • catch:可选执行的代码块,如果没有任何异常发生则不会执行;如果发现异常则进行处理或向上抛出。
  • finally:必选执行的代码块,不管是否有异常产生,即使发生OutOfMemoryError也会执行,通常用于处理善后清理工作。
  • finally代码块没有执行的三种可能:
    a.没有进入try代码块;
    b.进入try代码块,但是代码运行过程出现了死循环或死锁状态;
    c.进入try代码块,但是执行了System.exit()操作;
  • finally是在return表达式运行之后执行的,此时将要return的结果已经被暂存起来,待finally代码块执行结束后再将之前暂存的结果返回
  • finally代码块中使用return语句,会使返回值的判断变得复杂。

4.自定义异常类

 Java提供的异常类,不够我们使用,需要自己定义一些异常类。
   格式:public   class   XXXException   extends  Exception/RuntimeException{
                添加一个空参数的构造方法;
                添加一个带异常信息的构造方法;
          }

   注意:
        a.自定义异常类一般都是以Exception结尾,说明该类是一个异常类
        b.自定义异常类,必须得继承Exception或者RuntimeException
               继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译器异常,就必须处理这个异常,要么throws,要么try...catch
               继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)。·

5.多个异常使用捕获该怎么处理?

  1.多个异常分别处理。------>一个一个的处理,写多个try...catch
  2.多个异常一次捕获,多次处理。------>写一个try,里面写多个可能异常的代码,但是可以写多个catch来处理。
                                    注意:catch里面定义的异常变量,如果有子父类关系,那么子类的异常变量必须写在上边,否则就会报错。
  3.多个异常一次捕获一次处理。------->一个try,一个catch,catch里面写一个总的异常类型。


希望各位大神给作者多提一些建议,文中有错误或者不当之处,评论区里请留言,作者定会及时改正。大家喜欢的话点个赞,评论一下哇!谢谢支持!

;原文链接:https://blog.csdn.net/weixin_52506859/article/details/115407750
本站部分内容转载于网络,版权归原作者所有,转载之目的在于传播更多优秀技术内容,如有侵权请联系QQ/微信:153890879删除,谢谢!

推荐图文


随机推荐