异常

1.异常概念

Ⅰ.异常：指的是程序在执行过程中出现的非正常的情况，最终会导致JVM的非正常停止。

在java的面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

Ⅱ.异常体系

异常其实就是帮助我们找到程序问题。异常的根类是java.long.Throwable，旗下有两个子类：java.long.Error 和 java.long.Exception

Ⅲ.异常分类

Exception ：编译期异常，进行编译（写代码）java程序出现的问题

　　RuntimeException：运行期异常，java程序运行过程中出现的问题

Error：错误，相当于程序得了一个无法治愈的毛病，必须修改源代码，程序才能继续执行

Ⅳ.异常的产生过程解析

第一步：访问了数组中的3索引，而数组是没有3索引的，这时候JVM就会检测出程序会出现的异常。

　　　　JVM会做2件事：

　　　　1.JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的（内容，原因，位置）

　　　　　　new ArrayIndexOutOfBoundsException("3");

　　　　2.在getElement方法中，没有异常处理逻辑（try...catch），那么JVM就会把异常对象抛出给方法的调用者main方法来处理这个异常

第二步：main方法收到了这个异常对象（new ArrayIndexOutOfBoundsException("3");），mian方法也没有异常的处理逻辑，继续把对象抛出给方法的调用者JVM处理。

第三步：JVM接收到了这个异常对象（new ArrayIndexOutOfBoundsException("3");）。做了两件事情：

　　　　1.把异常对象（内容，原因，位置）以红色的字体打印在控制台。

　　　　2.JVM会终止当前正在执行的Java程序。——>中断处理

2.异常的处理

5个关键字：try、catch、finally、throw、throws

Ⅰ.Throw关键字

作用：可以使用throw关键字在指定的方法中抛出指定的异常

使用格式：

　　throw new xxxException("异常产生的原因")；

注意：

　　1.throw关键字必须写在方法的内部；

　　2.throw关键词后边new的对象必须是Exception或者Exception的子类对象；

　　3.throw关键字抛出指定的异常对象，我们就必须处理这个异常对象：

　　　　throw关键词后边创建的RuntimeException，或者是RuntimeException的子类对象，我们可以不处理，默认交给Jvm处理（打印异常对象，中断程序）

　　　　throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throws，要么try...catch。

 1 /*
 2 Throw关键字
 3     以后（工作中）我们首先必须对方法传递过来的参数进行合法性校验，
 4     如果参数不合法，我们就必须使用抛出异常的方式，告知方法的调用者  传递的参数有问题。
 5     注意：
 6           NullPointerException是一个运行期异常，我们不用处理，默认交给JVM处理
 7           ArrayIndexOutOfBoundsException是一个运行期异常，我们不用处理，默认交给JVM处理
 8  */
 9 public class Demo03Throw {
10     public static void main(String[] args) {
11         int[] arr = {1,2,3};
12         int e = getElement(arr, 3);
13         System.out.println(e);
14     }
15 
16     public static int getElement(int[] arr,int index){
17         //对传递过来的参数（数组）进行合法性的校验，
18         // 如果arr的值为空，我们就抛出空指针异常，告知方法的调用者“传递的数组值是null”
19         if (arr ==null ){
20             throw new NullPointerException("传递的数组值是null");
21         }
22         //我们可以对传递过来的参数index进行合法性校验，
23         // 如果index的范围不在数组的索引范围内，
24         // 那么我们就抛出数组索引越界异常，告知方法的调用者：传递的索引超出了数组的使用范围。
25         if ( index < 0 || index > arr.length-1 ){
26             throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
27         }
28         int i = arr[index];
29         return i;
30     }
31 }

Ⅱ.Objects非空判断

还记得我们学习过一个类objects吗，曾经提到过，他有一些静态的使用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的）那么在它的源码中，对对象为null的值进行了抛出异常操作。

　　public static <T> T requireNonNull(T obj) ：查看指定引用对象不是null

源码：

Ⅲ.声明异常

异常处理的第一种方式：抛出异常（交给别人处理）

作用：当方法内部抛出异常对象的时候，我们就必须处理这个异常对象，

　　　可以使用throw会把一场对象声明抛出给方法的调用者处理（自己不处理），最终交给JVM处理 ——> 中断处理。

使用格式：在方法声明时使用。

　　修饰符返回值类型方法名（参数列表） throws AAAException BBBException ...{

　　　　throw new AAAException("产生原因")；

　　　　throw new BBBException("产生原因")；

　　　　...

}

注意：

　　1.throws关键字必须写在方法声明处；

　　2.Those关键字后边声明的一场必须是exception或者exception的子类；

　　3.方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常

　　　　如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可；

　　4.调用了一个声明，抛出异常的方法，我们就必须处理声明的异常

　　　　要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM

　　　　要么try...catch自己处理异常。　　

有缺陷：异常后边儿的代码也不会在执行了。

Ⅳ.捕获异常

异常处理的第二种方式：捕获异常（自己来处理）

格式：try{

　　　　可能会产生异常的代码

　　}catch(定义一个异常的变量，用来接收try中抛出的异常对象){

　　　　异常的处理逻辑，产生异常对象之后怎么样处理异常对象

　　　　一般在把工作中，会把异常的信息记录到一个日志中。

　　}

　　......

　　catch(数据类型变量名){

　　}

注意：

　　1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象。

　　2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try catch之后的代码。

　　　如果try中没有产生异常，那么就不会称执行开始中异常的处理逻辑，执行完try中的代码，继续执行try catch之后的代码。

Throwable类中3个异常处理的方法

　　1.String getMessage() 返回此 throwable 的简短描述。

　　2.String toString() 返回此 throwable 的详细信息字符串。

　　3.void printStackTrace() JVM打印异常对象，默认此方法，打印的异常信息是最全面的。

Ⅴ.finally代码块

格式：try{

　　　　可能会产生异常的代码

　　}catch(数据类型变量名){

　　　　异常的处理逻辑，产生异常对象之后怎么样处理异常对象

　　}finally{

　　　　无论是否出现异常都会执行

　　}

注意：

　　1.finally不能单独使用，必须和try一起使用。

　　2.finally一般用于资源释放，无论程序是否出现异常，最后都要资源释放。

Ⅵ.异常注意事项

⑴多个异常使用捕获又该如何处理呢？

　　1.多个异常分别处理。

　　2.多个异常一次捕获，多次处理。

　　　　注：catch里面定义的异常变量如果有子父类关系，那么子类异常必须写在上面

　　3.多个异常一次捕获，一次处理。

⑵运行时异常被抛出可以不出理，即不捕获也不声明抛出。

⑶如果finally有return语句，则永远返回finally中的结果，所以要避免该情况。

⑷子父类异常

　　1.如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常，或者是父类异常的子类，或者不抛出异常。

　　2.父类方法没有抛出异常，子类重写父类方法时也不可抛出异常，此时子类产生该异常，只能捕获处理，不能声明抛出。

　　3.在try...catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。

注：父类异常是什么样，子类异常就什么样

public class Fu {
    public void show1() throws NullPointerException,ClassCastException{}
    public void show2() throws IndexOutOfBoundsException{}
    public void show3() throws IndexOutOfBoundsException{}
    public void show4(){}
}

class Zi extends Fu{
    //子类重写父类方法是抛出和父类相同的异常。
    public void show1() throws NullPointerException,ClassCastException{}
    //子类重写父类方法时，抛出父类异常的子类。
    public void show2() throws ArrayIndexOutOfBoundsException{}
    //子类重写父类方法时，不抛出异常。
    public void show3(){}
    //处理方法没有抛出异常，子类重写父类方法时也不能抛出异常。
    //public void show4(){}
    //此时只能try...catch
    public void show4(){
        try{
            throw new Exception("编译器异常");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

3.自定义异常

格式：

　　public class XXXException exends Exception | RuntimeException {

　　　　　　添加一个空参数的构造方法

　　　　　　添加一个带异常信息的构造方法。

　　}

注意：

　　1.自定义异常类一般是以Exception结尾。说明该类是一个异常类。

　　2.自定义异常类必须继承Exception或者RuntimeException

　　　　继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这个异常，那么throws，要么try catch

　　　　继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理 ——>中断处理

posted @ 2020-03-25 19:40 佥刂同学阅读(190) 评论(0) 收藏举报

刷新页面返回顶部

佥刂同学

异常