①. 异常的概述和分类

①. Error:严重问题,不需要处理
②. Exception:称为异常,它表示程序本身可以处理的问题

RuntimeException:在编译期是不检查的,出现问题后,需要我们回来修改代码
非RuntimeException:编译器就必须处理,否则程序不能通过编译,就更不能正常运行了

在这里插入图片描述

②. Jvm默认是如何处理异常的

①. Jvm有一个默认的异常处理机制,就将该异常进行处理。并将该异常的名称,异常的信息,异常出现的位置打印在了控制台上
②. 同时将程序停止运行

//看异常从后往前看,先看这里的 java:6  再看 java:14
public class JvmException {
    public static void main(String[] args) {
        DemoJvm d=new DemoJvm();
        int x=d.div(1,0);
        System.out.println(x);//ArithmeticException: / by zero
    }
}
class DemoJvm{
    public int div(int a,int b){//a=10 b=0
        // 10/0 被除数是10,除数是0当除数是0的时候违背了算数运算法则,抛出异常
        // new ArithmeticExcpetion("/ by zero")
        return a/b;
    }
}

在这里插入图片描述

③. try–catch的方式处理异常

①. try–catch的方式处理异常
try:用来检测异常的；catch:用来捕获异常的；finally:用来释放资源的
世界上最真情的相依就是你在try 我在catch,无论你发神马脾气,我都静静接受,默默处理

	// 异常处理的两种方式
	try.....catch.....finally
	1.try.....catche
	2.try.....catche.....finally
	3.try.....finally
	throws

- ②. 当通过trycatch将问题处理了,程序会继续执行

在这里插入图片描述

③. try后面如果跟多个catch,那么小的异常放前面,大的异常放后面,根据多肽的原理,如果大的放前面,就会将所有的子类对象接受,后面的catch就没有意义了

在这里插入图片描述

④. 编译期异常和运行期异常的区别

①. 所有的RuntimeException类及其子类的实例被称为运行时异常,其他的异常就是编译时异常
②. 编译时异常:Java程序必须显示处理,否则程序就会发生错误,无法通过编译
③. 运行时异常:无需显示处理,也可以和编译时异常一样处理

在这里插入图片描述

⑤. Throwable的集中常见方法

①. String getMessage():获取异常信息,返回字符串
②. String toString():获取异常类和异常信息,返回字符串
③. void printStackTrace():获取异常类名和异常信息,以及异常出现在程序中的位置,返回值为void (Jvm 默认这种方式)

    try{
        System.out.println(1/0);
    }catch (Exception e){
        //Exception e =new ArithmeticException("/ by zero");
        System.out.println(e.getMessage());//获取异常信息 / by zero
        //toString():打印异常类名和异常信息
        System.out.println(e.toString());//java.lang.ArithmeticException: / by zero
        System.out.println(e);//java.lang.ArithmeticException: / by zero
        //printStackTrance():JVM 默认这样方式处理
        e.printStackTrace();
        //at day08.ExcepetionDemo.main(ExcepetionDemo.java:8)
        //java.lang.ArithmeticException: / by zero
    }

⑥. throws的方式处理异常

①. 编译时异常的抛出,必须对其进行处理
②. 运行时异常的抛出,可以处理也可以不处理

在这里插入图片描述

③. throw:在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时,就用throw把异常对象抛出

	//掌握
	throws:
	1. 用在方法声明后面,跟的是异常类名
	2. 可以跟多个异常类名,用逗号隔开
	3. 表示抛出异常,由该方法的调用者来处理
	throw:
	1. 用在方法体内,跟的是异常对象名
	2. 只能抛出一个异常类对象名
	3. 表示抛出异常,由方法体内的语句处理
	   Exception e=new Exception("年龄非法");
	   throw e;

⑦. finally最后执行

①. 被finally控制的语句体一定会执行
②. 特殊情况:在执行到finally之前jvm退出了(比如:System.exit(0))

//return语句相当于是方法的最后一口气,那么在它将死之前会看一
//看有没有finally帮其完成遗愿。如果有就将finally执行后切底返回
 try{
         System.out.println(10/0);
     }catch (Exception e){
         System.out.println("除数为0了");
         return;
     }finally {
         System.out.println("一定会执行的");
     }

③. final,finally和finalize的区别

1.final,finally和finalize的区别
final:
final可以修饰类,不能为继承
final修饰方法,不能被重写
final修饰变量,只能赋值一次

finally:
finally是try语句中的一个语句体,不能单独使用,用来释放资源

finalize:
是一个方法,当垃圾回收器确定不存在对该对象的更多引用时,
由对象的垃圾回收器调用次方法

2.如果catch里面有return语句,请问finally的代码还会执行吗？如果会,请问在return前还是retrun后
会执行,在return前执行

在这里插入图片描述

⑧. 自定义异常概述和基本使用

①. 异常的注意事项

子类重写父类方法时,要求子类抛出的异常要小于父类抛出的异常
如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内部有异常发生,那么子类只能try,不能throws

②. 如何使用异常处理
原则:如果该功能类部可以将问题处理,用try,如果处理不了,交由调用者处理,这里用throws

//Exception是编译时异常
//RuntimeException时运行时异常
public class ScoreException extends Exception/*RuntimeException*/ {
     public ScoreException(){
     }
     public ScoreException(String message){
         super(message);
     }
}

public class Teacher {

    public void checkScore(int score)throws ScoreException{
        if(score<0||score>100){
            //throw new ScoreException();
            throw new ScoreException("你输入的数字有误");
        }else{
            System.out.println("正确");
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你的成绩:");
        int score=sc.nextInt();
       Teacher t=new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}