Java之异常体系

1. 异常体系分类：
   1. Error 错误
   2. Exception 异常
2. 错误和异常的继承关系：
   1. 所有错误的父类为 Error 类
   2. 所有异常的父类为 Exception 类
   3. Error 和 Exception 的父类为 Throwable
   4. Throwable：代表可抛出
3. 错误类型：
   1. 编译错误：由编译器找到的错误

      String a = 1;    //编译错误,没有加引号

   2. 异常错误：程序给我们提示

      Class calzz = Class.forName("com.demo.Animal");

   3. 逻辑异常：不会报错，但是必须注意到它有异常，这种异常是逻辑产生的

      int[] arr = new int[5];
      arr[10] = 45;    //没有报错，但是必须注意到这个错误

   4. 栈溢出错误

      public static void main(String[] args){
          run();    //这里有错误，会产生栈溢出
      }
      
      public static void run(){
          run();
      }

4. Error 错误：
   1. Error 错误是程序无法处理的错误，它是由 JVM 产生和抛出的
5. Exception异常：
   1. 运行时异常(非受检异常)
   2. 非运行时异常(受检异常)
6. 运行时异常(非受检异常)：
   1. 由逻辑错误引起
   2. 在编译时异常，必须解决的异常
7. 处理受检异常：
   1. 抛出
   2. 解决
8. 受检异常解决方法：
   1. try catch 环绕：
      1. try：找到错误
      2. catch：处理错误
      3. finally：不管有没有异常都必须执行的代码块，常用于关闭资源

         public static void main(String[] args){
             try{
                 //获取异常
             }catch(){
                 //解决异常   
             }finally{
                 // 最终都会走的代码
             }
         }

      4. 尝试去处理问题，但是处理不了，finally 也能保证后面程序的运行

         public static void main(String[] args){
             try{
                 int[] arr = new int[5];
                 int[10] = 10;    //这会有异常
             }catch(){
                 //处理异常   
                 ······
             }finally{
                 //此行代码不管上方有没有错误都会去执行
                 System.out.println("---------------");
             }
         }

      5. catch 可以有多个，分别处理不同的情况

         public static void main(String[] args){
             try{
                 int[] arr = new int[5];
                 int[10] = 10;    //这会有异常
             }catch(ArrayIndexOutOfBoundsException e){
                 //处理异常   
                 ······
             }catch(NegativeArraySizeException e){
                 //处理异常   
             }···
         }

      6. 如果不想使用多个 catch，可以用 Exception 把所有异常兜住

         public static void main(String[] args){
             try{
                 int[] arr = new int[5];
                 int[10] = 10;    //这会有异常
             }catch(Exception e){
                 //解决所有异常问题   
                 ······
             }
         }

      7. Exception 类是所有异常类的父类
   2. 抛出：
      1. throws：表示此方法不去处理异常，而交给方法调用者进行处理

         public class Test{
                                                 // 异常抛出
             public static void main(String[] args) throws Exception{
                     
             }
         }

      2. throw：自定义异常

         try{
             //自定义异常
             throw new Exception("自定义异常");
         }catch(Exception e){
             //打印异常
             System.out.println(e);
         }

      3. throw 和 throws 区别：
         1. throws：用来声明一个可能产生的所有异常，不做异常处理而是将异常向上传递，将异常抛给调用者
         2. throw：用来抛出一个具体的异常类型
9. 异常体系整体框架：