java进阶打卡14

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

（1）String getMessage() 返回此Throwable的简短描述
例如：	System.out.println(e.getMessage());//文件的后缀名不对

（2）String toString() 返回此Throwable的详细信息字符串
例如：	System.out.println(e.toString());//java.io.IOException: 文件的后缀名不对
		System.out.println(e);//java.io.IOException: 文件的后缀名不对
		//重写Object类的toString，所以e.toString == e
		
（3）void printStackTrace() JVM打印异常对象，默认此方法，打印的异常信息是最全面的
例如：	e.printStackTrace();
		/*java.io.IOException: 文件的后缀名不对
			at day05.demo02.Demo01TryCatch.readFile(Demo01TryCatch.java:52)
			at day05.demo02.Demo01TryCatch.main(Demo01TryCatch.java:27)*/

finally代码块

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

    }finally{
        无论是否出现异常都会执行
    }
注意：
    1. finally不能单独使用，必须和try一起使用
    2. finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放（IO）

异常的注意事项

• 多异常的捕获处理

多个异常使用捕获又该如何处理呢？
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。

一个try多个catch注意事项：
	catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则子类异常变量没有使用，就会报错
	ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException

try{
	int[] arr = {1, 2, 3};
    //System.out.println(arr[3]); // ArrayIndexOutOfBoundsException: 3
    List<Integer> list = List.of(1, 2, 3);
    System.out.println(list.get(3)); // IndexOutOfBoundsException：Index 3 out-of-bounds for length 3
}catch(ArrayIndexOutOfBoundsException e){
	System.out.println(e);
}catch(IndexOutOfBoundsException e){
    System.out.println(e);
}

分析：
try中可能会产生的异常对象：
	new ArrayIndexOutOfBoundsException("3");
	new IndexOutOfBoundsException("3");
try中如果出现了异常对象，会把异常对象抛出给catch处理，抛出的异常对象，会从上到下依此赋值给catch中定义的异常变量
ArrayIndexOutOfBoundsException	=	new ArrayIndexOutOfBoundsException("3");
IndexOutOfBoundsException		=	new IndexOutOfBoundsException("3");
-------------------------------------------------------------------------------------------------------
IndexOutOfBoundsException		=	new ArrayIndexOutOfBoundsException("3");	多态
IndexOutOfBoundsException		=	new IndexOutOfBoundsException("3");

多个异常一次捕获一次处理：
try{
	int[] arr = {1, 2, 3};
	//System.out.println(arr[3]); // ArrayIndexOutOfBoundsException: 3
    List<Integer> list = List.of(1, 2, 3);
    System.out.println(list.get(3)); // IndexOutOfBoundsException：Index 3 out-of-bounds for length 3
}catch(Exception e){
    System.out.println(e);
}

运行时异常被抛出可以不处理。既不捕获也不声明抛出。
默认给虚拟机处理，终止程序，什么时候不抛出运行时异常了，再来继续执行程序

• finally有return语句
  如果finally有return语句，永远返回finally中的结果，避免该情况。
• 子父类异常

子父类的异常：
    如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
    父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
注意：
    父类异常是什么样，子类异常就是什么样

public class Fu {
    public void show01() throws NullPointerException, ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04(){}
}
class Zi extends Fu{
    // 子类重写父类方法时，抛出和父类相同的异常
    public void show01() throws NullPointerException, ClassCastException{}
    // 子类重写父类方法时，抛出父类异常的子类
    public void show02() throws ArrayIndexOutOfBoundsException{}
    // 子类重写父类方法时，不抛出异常
    public void show03() {}

    // 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。
    // public void show04() throws Exception{} // 错误写法！
    //此时子类产生该异常，只能捕获处理，不能声明抛出
    public void show04(){
        try {
            throw new Exception("编译期异常");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}