Java进阶—异常

一、异常概念

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

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

注意,异常指的并不是语法错误,否则,编译就不会通过,不会产生字节码文件,不能运行。

二、异常体系

异常机制其实是帮助我们找到程序中的问题,异常的根类是java.lang.Throwable,其下有两个子类:
java.lang.Error和java.lang.Exception。

Throwable体系:

    Error:严重错误Error,无法通过处理的错误,只能实现避免,好比绝症

    Exception:表示异常,异常产生后程序员可以通过代码的方式纠正,使程序继续运行,是必须要处理好的。好比于感冒

Throwable中的常用方法:

    public void printStackTrace():打印异常的详细信息
    包含了异常的类型,异常的原因,异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

    public String getMessage():获取异常发生的原因
    提示给用户的时候,就提示错误原因

    public String toString():获取异常的类型和异常描述信息(不用)

三、编译期异常 VS 运行期异常
java.lang.Throwable:该类是Java语言中所有错误或异常的超类。
它有两个子类:

    Exception:编译期异常,进行编译(写代码的时候)时,java程序出现的问题
        Exception下面还有一个子类:
            RuntimeException:运行期异常,Java程序运行过程中出现的问题
            异常就相当于程序得了一个小毛病(好比感冒),把异常处理掉(好比吃点药),程序可以继续执行

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

Exception:【编译期异常】,进行编译(写代码的时候)时,java程序出现的问题

第一种处理方式:throws ParseException,交给JVM处理
JVM会中断程序,然后将异常打印在终端
第二种处理方式:surround with try/catch
该方式有一个好处:可以将异常信息打印出来,但是后面的代码可以继续执行

RuntimeException:【运行期异常】,Java程序运行过程中出现的问题
使用try/catch来处理这个异常,使用try/catch时,【即使出现了异常,后面的代码也可以【继续执行】

try {
	//try中放的是可能会出现异常的代码
	
}catch (Exception e){
    //catch中放的是异常的处理逻辑

}

Error

必须修改源代码,才能改正Error错误
和异常不同,异常处理完之后可以继续执行

异常的产生过程解析:

    //在main方法中,调用方法arrayValueOfIndex
    int value = arrayValueOfIndex(array, 3);

    //在arrayValueOfIndex方法中
    int value = array[index];   此时index=3

    一、即访问了数组中的3索引,而数组是没有3索引的,这时候,JVM就会检测出程序会出现异常,JVM会做两件事:

        1.JVM会根据异常产生的原因创建一个异常对象,这个异常对象包含了异常产生的内容、原因和位置
            new ArrayIndexOutOfBoundsException("3");

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

   二、main方法接收到了这个异常对象(new ArrayIndexOutOfBoundsException("3");),main方法中也没有异常处理逻辑,就会继续把对此昂抛出给main方法的调用者JVM处理。

   三、JVM接收到了这个异常对象(new ArrayIndexOutOfBoundsException("3");),做了两件事:

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

        2.JVM会终止当前正在执行的java程序——【中断处理】

throw关键字

throws关键字:异常处理的第一种方式,交给别人处理

作用:
	当方法内部抛出异常对象的时候,我们就必须处理这个异常对象
	
    可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理——中断处理

使用格式:
    在方法声明时使用,抛出多少个,就声明多少个:
    修饰符 返回值类型 方法名(参数列表) throws AAAException, BBBException{  // 声明多个异常
        // 抛出多个异常
        throw new AAAException("产生原因");
        throw new BBBException("产生原因");
    }
注意事项:
    1.throw关键字必须写在方法的内部
    
    2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
    
    3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象,方法内部如果【抛出】了多个异常对象,那么throws关键字后面也必须【声明】多个异常,如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可。
    
    4.throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断处理)
      throw关键字后边创建的是【编译异常】,我们就必须处理这个异常,要么throws,要么try...catch

try…catch:

try...catch:异常处理的第二种方式,自己处理异常

格式:
    try{
        可能产生异常的代码
    }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
        异常的处理逻辑,异常对象之后,怎么处理异常
        一般在工作中,会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){
    }

注意事项:
    1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
    2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的
      处理逻辑,继续执行try...catch之后的代码。
      如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,
      继续执行try...catch之后的代码。

finally代码块:

格式:
    try{
        可能产生异常的代码
    }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
        异常的处理逻辑,异常对象之后,怎么处理异常
        一般在工作中,会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){
    }finally{
        无论是否出现异常,都会执行
    }

注意事项:
    1.finally不能单独使用,必须和try一起使用
    2.finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)

多个异常使用捕获该如何处理?

1.多个异常分别处理

2.多个异常一次捕获,多次处理
	一个try,多个catch,注意事项:
     	catch里面定义的异常变量,如果有子父类关系,那么子类的异常变量,必须写在上面,否则就会报错
        ArrayIndexOutOfBoundsException是IndexOutOfBoundsException的子类,所以ArrayIndexOutOfBoundsException 放在了上面。
        
        原因分析:
            try中可能会产生的异常对象:
                new ArrayIndexOutOfBoundsException("3");
                new IndexOutOfBoundsException("3");

            try中如果出现了异常对象,会把异常对象抛出给catch处理
            抛出的异常对象,会从上到下【依次赋值】给catch中定义的异常变量:
                ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException("3");
                IndexOutOfBoundsException e = new IndexOutOfBoundsException("3");
                这样是没有问题的。
            但是如果父类变量写在了子类变量上边,则会有问题:
                IndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException("3");  //多态写法
                IndexOutOfBoundsException e = new IndexOutOfBoundsException("3");
                也就是,不管是哪一个异常对象,都可以由父类异常变量接收,所以子类异常变量是没有被用到的,会报错

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

4.如果finally有return语句,永远返回finally中的结果,避免该情况,即finally中不要写return语句。

子父类的异常:

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

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

注意:
    【父类异常是什么样,子类异常就是什么样】

Objects类中的静态方法:

public static <T> T requireNull(T obj):查看指定引用对象不是null。
源码:
    public static <T> T requireNonNull(T obj){
        if(obj == null)
            throw new NullPointerException();
        return obj;
    }

自定义异常类:

java提供的异常类,不够我们使用,需要自己定义一些异常类

格式:
    public class XxxException extends Exception/Runtime Exception{
        添加一个空参构造方法
        添加一个带异常信息的构造方法
    }
注意:
    1.自定义异常类一般都是以Exception结尾,说明该类是一个异常类
    2.自定义异常类,必须继承Exception或者RuntimeException
        继承Exception,那么自定义的异常类,就是一个编译期异常,如果方法内部抛出了编译器异常,就必须处理这个异常,要么throws,要么try...catch
        继承RuntimeException,那么自定义的异常类,就是一个运行期异常,无需处理,交给JVM处理——中断处理。

添加一个带有异常信息的构造方法:
    查看源码发现,所有的异常类都会有一个带异常信息的构造方法,方法内部会调用父类带异常信息的方法,让父类来处理这个异常信息,实际上调用的是父类的空参构造方法。
上一篇:LeetCode 121 Best Time to Buy and Sell Stock(股票买入卖出的最佳时间)


下一篇:分类任务中样本不均衡解决方案