【异常】异常分类，处理异常方法，获取异常信息的方法，throws异常，throw异常， final,finally和finalize的，finally区别，catch里面有return语句，

异常

1.异常：指的是程序出现不正常的情况

（此案例，仅做上课使用，生活如有雷同，纯属巧合，概不负责）
举例：今天天气很好，班长出去爬大蜀山，骑哈罗单车去，去山呼吸新鲜空气。
问题1：山路突然崩塌了，班长及时停住，但是路过不去了。这属于严重的问题。
问题2：班长开了一个哈罗单车，发现半路没电了，自己想办法充电，充完电后到了。这样的问题，班长在出发之前就应该考虑到的。
问题3：班长骑着车正在欣赏风景，山路不太好骑车，都是小石子，中间是平坦的水泥路
如果一直在水泥路上骑车，这是没问题的。但是呢，班长偏偏不走那边，就喜欢走小石子利用，结果半路，车胎爆了。
这样的问题属于上山过程中出现的问题。

2.异常分类图解

对应到java中异常的分类
java中的异常：Throwable
严重的问题：Error,我们不处理，这样的问题一般都是很严重的，比如说内存溢出（OOM）
问题：Exception（异常）
编译时期异常：除了RuntimeException都是编译时期异常，必须要处理，如果不处理，程序编译无法通过，无法运行。
运行时期异常：RuntimeException，这样的问题，一般情况下，我们不会对问题本身处理，因为这样的问题是自己在写代码
过程中由于逻辑的不严谨导致的。

如果程序出现了问题，我们并且没有做任何处理，最终JVM会做出默认的处理
把异常的名称，相关的原因，以及出现问题的信息输出在控制台上
同时程序会停止，而且后续的代码不会执行。
运行时的异常：

public class ExceptionDemo1 {
    public static void main(String[] args) {
int a=10;
int b=0;
        System.out.println(a/b);//ArithmeticException



    }
}

3.处理异常方法

（1）.处理一个异常的情况

1、try…catch…finally
2、throws

try…catch…finally的处理格式：
try{
可能会出现问题的代码
}catch(异常类名 变量名){
针对出现问题后的处理代码
}finally{
只要是程序顺利进行，finally里面的内容无论如何都会执行
}

变形格式：
try{
可能会出现问题的代码
}catch(异常类名 变量名){
针对出现问题后的处理代码
}

注意事项：
1、try里面的代码越少越好
2、catch必须要有内容，哪怕是一句简单的提示

          public class ExceptionDemo2 {
    public static void main(String[] args) {
        int a=20;
        int b=0;
        try {
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("除数为零。。。。");
        }
        System.out.println(a);
    }
}

结果：

(2).处理2个及两个以上的异常的情况

1. 每一个异常写一个try…catch
   2) 写一个try,多个catch
   try{
   可能会出现问题的代码
   }catch(异常类名1 变量1){
   针对于异常1做的处理方案
   }catch(异常类名2 变量2){
   针对于异常2做的处理方案
   }…

当处理多个异常使用第二种方案的时候需要注意的事项：
1、catch只能匹配对应的异常，并且只能匹配一个异常
2、平级关系的异常顺序无所谓，如果出现了父子继承关系，父类（Exception）必须放在最后
3、try里面如果出错了，try中后面的代码不会执行，就会匹配catch中的异常，
匹配到后执行解决方案，后面的代码正常执行
4、catch中的异常类名，尽量明确，不要用大的异常去处理

public class ExceptionDemo3 {
    public static void main(String[] args) {
fun();
fun1();
    }
    public static  void fun(){
        int a=20;
        int b=0;
        int[] arr={2,3,4};
        try {
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("除数为零。。。。");
        }
        try {
            System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException t){
            System.out.println("数组下标索引越界");
        }
        System.out.println("helloworld");
        /*
        除数为零。。。。
        数组下标索引越界
        helloworld
         */
    }


    public static void fun1(){
        int a=80;
        int b=0;
        int[] arr={8,3,43,1};
        try {
            System.out.println(a/b);
            System.out.println(arr[4]);
        }catch (ArithmeticException e){
            System.out.println("除数为零。。。。");
    //走到这里，报错了，try后面的代码不会继续执行，直接去匹配
    //catch中的异常
        }
        catch (ArrayIndexOutOfBoundsException t){
            System.out.println("数组下标索引越界");
        }
        System.out.println("happyday");
        /*结果：
        除数为零。。。。
        happyday

         */
    }
}

结果：

（3）. JDK1，7后出现的处理多个异常的方式：

格式： try{
可能会出现问题的代码
}catch(ArrayIndexOutOfBoundsException | ArithmeticException | …){
处理问题的方案
}

注意事项：
1、处理方式是一致的，这个方式虽然简洁，但是也不够好，针对多种数据类型的异常，只给出了一种解决方案
2、这样的方式，catch中只能写平级关系的异常类！！！

 public class ExceptionDemo4 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        int[] arr={23,12,53,123,432,};
        try {
            System.out.println(a/b);
            System.out.println(arr[5]);
        }catch (ArithmeticException|ArrayIndexOutOfBoundsException E){
            System.out.println("出错了");
        }
        System.out.println("helloworld");
        //出错了
        //helloworld
        }
    }

结果：

（4）编译时期异常与运行时时期异常的区别：

编译时期异常：Java程序必须要显示的处理，否则程序就会发生错误，无法通过编译，不能运行
运行时期异常：一般情况下，不去处理，修改代码逻辑，也可和编译时期异常做一样的处理

编译时异常

public class ExceptionDemo5 {
    public static void main(String[] args) {
        String s = "2022-02-16 15";
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd: HH:mm:ss");
        try {
            Date parse = format.parse(s);//编译时异常
            System.out.println(parse);
        }catch (ParseException p){
            System.out.println("日期转换异常");
        }
        System.out.println("helloworld");

    }
}

结果：

4.获取异常信息的方法

（1） getMessage()： 获取异常信息，返回字符串。

（2） toString()

获取异常类名和异常信息，返回字符串。
返回此异常类名+": "+getLocalizedMessage()
而getLocalizedMessage()内部默认调用的是getMessage()

（3）printStackTrace()

获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

public class ExceptionDemo6 {
    public static void main(String[] args) {
        String s = "2022-02-16 15";
        SimpleDateFormat format = new 
        SimpleDateFormat("yyyy/MM/dd:HH mm ss");
        try {
            Date parse = format.parse(s);
            System.out.println(parse);
        }catch (ParseException p){
            String message = p.getMessage();
            System.out.println(message);
            //Unparseable date: "2022-02-16 15"
            String s1 = p.toString();

            System.out.println(s1);
//java.text.ParseException: Unparseable date: "2022-02-16 15"
            p.printStackTrace();
  /*java.text.ParseException: Unparseable date: "2022-02-16 15"
            at java.text.DateFormat.parse(DateFormat.java:366)
            at com.shujia.wyh.day02.day21.ExceptionDemo6.main(ExceptionDemo6.java:23)*/

        }
        System.out.println("helloworld");//此句最终会运行
    }
}

结果:

5.throws异常

引入： 有些时候，我们可以对异常进行处理，但是有些时候，我们根本就没有权限去处理某个异常
处理不了，我们干脆不处理了。
但是呢，我们不处理又报错，影响后面代码的执行
为了解决这样的问题，并且还能让程序继续执行，Java针对这种情况，提供了另一种处理异常方案：throws 抛出

语句定义格式：
throws 异常类名
注意：
1、这个格式必须跟在方法的小括号后面，大括号的前面。
2、尽量不要在main方法上面抛出

总结：
1、编译时期异常抛出，将来调用者必须做处理
2、运行时期异常抛出，将来调用着依旧要做处理

public class ExceptionDemo7 {
    public static void main(String[] args)
    //throws ParseException 这里我们不能再抛出异常，否则就又
   //抛给了JVM虚拟机
     {
 try {
     fun();
 }catch (ArithmeticException e){
     e.printStackTrace();
 }
 try {
     fun1();
 }catch (ParseException p){
     p.printStackTrace();
 }

        System.out.println("helloworld");

    }


    public static void fun()throws ArithmeticException{
        //在运行时期异常时，即使你用throws抛出异到main方法中，
    //依然要在main中对fun（）做异常处理，否则运行时还会报错
        int a=10;
        int b=0;
        System.out.println(a/b);
    }


    public static void fun1()throws ParseException {
    //即使这里你抛出了异常但在main()中调用fun1（）还是会报错，
    //因此依然要处理异常
        String s="2022-2-16 20";
        SimpleDateFormat format = new SimpleDateFormat("yyyy MM dd:HH mm ss");
        Date parse = format.parse(s);
        System.out.println(parse);
    }
}

6.throw异常

throw:在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
注意：此时用throw抛出的是异常类的对象

throws与throw的区别：

throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常

故事理解throws与throw:
加入你是一个快乐小矿工，有一天正在挖矿，挖着挖着，挖出来一个二战时期遗留的炸弹（异常），怎么办？
肯定不能在矿井中就直接引爆（不能直接就处理了），所以应该传递出去（throw抛出异常对象）。然后你带着这个炸弹来到了矿井扣，发现你们小队
挖的这块地方，是二战时期炸弹聚集地，所以理所当然会挖出炸弹，很多矿工都挖到了，都会传出来（throws ,表示一次性可以抛出多个异常），
传给谁呢？传给的是矿井负责人（调用着）进行处理。大家都挖到了炸弹，为了区分，每个人都有权力给自己的炸弹命名（throw可以抛出自定义异常对象）。

public class ExceptionDemo8 {
    public static void main(String[] args) {
        try {
            fun();
        }catch (ArithmeticException a){
            a.printStackTrace();
        }catch (ParseException p){
            p.printStackTrace();
        }
    }
    public static void fun()throws ArithmeticException, ParseException {
        int a=10;
        int b=0;
        if (b==0){
            System.out.println("helloworld");
             throw new ArithmeticException();

        }
        else {
            System.out.println(a/b);
        }
    }
}

结果：

7. final,finally和finalize的区别

final: 最终的意思，可以修饰类，成员变量，成员方法
修饰类：类不能被继承
修饰成员变量：变量变常量
修饰成员方法：方法不能被重写

finally: 是属于处理异常try…catch…finally的一部分，一般是用于释放资源，正常情况下，都会执行，
除非在执行finally之前，程序停止。

finalize: 是Object类中一个方法，是用于垃圾回收的，堆内存中的空间没有栈的引用指向它，但是什么时候回收我们不确定。‘

7.如果catch里面有return语句，请问finally的代码还会执行吗? 会执行，如果会，请问是在return前还是return后?在之间执行。

public class ExceptionDemo9 {
    public static void main(String[] args) {
        int anInt = getInt();
        System.out.println(anInt);//30
    }
    public static int getInt(){
        int a=10;
        try {
            System.out.println(a/0);
            a=20;

        }catch (ArithmeticException e){
            a=30;
            return a;// 走到这里就已经生成了一个返回路径
//a=30;即使也会走finall的a=40,但是在此a=30，已经return，所以
//最终结果也是30
        }
        finally {
            a=40;

        }
        return a;
    }
}

结果：

8. finally: 被finally控制语句体最终一定会执行，特殊情况除外，特殊情况：在执行finally控制语句体之前，JVM就退出了

格式：try…catch…finally

public class FianallyDeno {
    public static void main(String[] args) {
        String s = "2022-02-16 16:";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date=null;
        try {
             date = simpleDateFormat.parse(s);
            System.out.println(date);
        }catch (ParseException p){
            p.printStackTrace();
           // System.exit(0);//让程序停止
 //当在finally之前结束程序，fianally就不会执行，否则无论catch
 //是否执行，finally都会执行，
 // 也就是说无论是否有异常finally也会执行
        }finally {
            //一般情况下，finally里面写的是用于
            //IO操作和针对于数据库操作，经常遇见
            System.out.println("此句一定会执行");
        }
        System.out.println(date);
    }
}