大数据 -- java基础12 异常

1、异常 :   指的是程序出现不正常的情况。

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

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

我们自己如何处理异常呢？
      (1)try…catch…finally
      (2)throws

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

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

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

public class ExceptionDemo1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
//        System.out.println(a / b);    // ArithmeticException
//
//        if(b!=0){
//            System.out.println(a/b);
//        }
//
//        System.out.println(10);   // 不会执行


        try {
            System.out.println(a / b);
        } catch (ArithmeticException e) {
            System.out.println("除数为0");
        }
        System.out.println(10);
    }
}

2、try...catch... :

   (1)处理一个异常的情况。

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

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


    JDK1.7后出现的处理多个异常的方式:
           try{
               可能会出现问题的代码
           }catch(ArrayIndexOutOfBoundsException | ArithmeticException | ... e){
               处理问题的方案
           }

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

public class ExceptionDemo2 {
    public static void main(String[] args) {

        fun1();
        fun2();
        fun3();

    }


    //处理2个及两个以上的异常的情况:  每一个异常写一个try...catch
    public static void fun1() {
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);          // ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("除数为0");
        }
        System.out.println("over1");

        int[] arr = {1, 2, 3};
        try {
            System.out.println(arr[4]);         // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException q) {
            System.out.println("数组下标越界");
        }
        System.out.println("over2");
    }


    //处理2个及两个以上的异常的情况:  一个try, 多个catch
    public static void fun2() {
        int a = 10;
        int b = 0;
        int[] arr = {1, 2, 3};

        try {
            System.out.println(a / b);   //走到这里，报错了，try后面的代码不会继续执行，直接去匹配catch中的异常
            System.out.println(arr[4]);
        } catch (ArithmeticException a1) {
            System.out.println("除数为0");
        } catch (ArrayIndexOutOfBoundsException a2) {
            System.out.println("数组下标索引越界");
        }
        System.out.println("over3");        // 会执行
    }


    // =========== JDK1.7后处理多个异常的方式: ============
    public static void fun3() {
        int a = 10;
        int b = 5;
        int[] arr = {1, 2, 3};

        try {
            System.out.println(a / b);
            System.out.println(arr[4]);
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("出错了");
        }
        System.out.println("over4");
    }
}

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

     注意: 此时用throw抛出的是异常类的对象。

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

public class ThrowDemo {
    public static void main(String[] args) {

        try {
            fun();
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
        System.out.println("over");

    }


    public static void fun() throws ArithmeticException {
        int a = 10;
        int b = 0;

        if (b == 0) {
            //System.out.println(a / b);
            throw new ArithmeticException();     // 当b=0，a/b一定会抛出异常，所以用throw抛出
        } else {
            System.out.println(a / b);
        }
    }
}

4、finally:   被finally控制语句体最终一定会执行，特殊情况除外

    特殊情况：在执行finally控制语句体之前，JVM就退出了

    格式：try...catch...finally

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

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

public class FinallyDemo {
    public static void main(String[] args) {

        //日期转化
        String s = "2022-02-16 16:";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date date = null;

        try {
            date = sdf.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
            System.exit(0);        //让程序停止
        } finally {
            //一般情况下，finally里面写的是用于IO操作和针对于数据库操作，经常遇见
            System.out.println("这里的代码一定会执行！");
        }
        System.out.println(date);

        System.out.println(getInt());    // 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;
        } finally {
            a = 40;
            System.out.println(a);
//            return a;
        }
        return a;
    }
}