Java中异常的基础知识

异常机制

什么是异常

1. 异常是指程序运行中出现的不期而至的各种状况
2. 异常发生在程序运行期间，它影响了正常程序执行流程
3. 异常的英文为：Exception

简单的分类

1. 检查类异常：最具代表的检查类异常时用户错误输入引起的异常
2. 运行时异常：运行时异常时可能被程序员避免的异常
3. 错误Error：错误不是异常，而是脱离程序员控制的问题

异常体系结构

1. Java把异常当做对象来处理，并定义了一个父类，Java.lang.Throwable作为所有异常的超类

2. 异常类分为两大类：错误Error和异常Exception

3. Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关

4. Exception：

   • 在Exception分支中有一个重要的子类，RunTimeException（运行时异常），程序中可以捕获处理。
   • 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常发生

5. Error和Exception的区别：Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exceptio通常情况下是可以被程序处理的，并且在程序中应该尽量的去处理这些异常

异常的处理机制

1. 抛出异常

2. 捕获异常

3. 使用的关键字为：try catch finally throw throws

   package com.exception.demo01;
   
   public class Test01 {
       public static void main(String[] args) {
           int a=10;
           int b=0;
           /*
           1.try和catch必须一起存在
           2.可以有多个catch（）
           3.如果要捕获多个异常，我们异常的范围需要从小到大的去捕获
            */
   
           try{//try:表示的是一个监控区域
               new Test01().a();
               new Test01().b();
               System.out.println(a/b);
           }catch(ArithmeticException test){
               //catch（想要捕获的异常类型）:捕获监控区域内出现的异常
               System.out.println("ArithmeticException");
           }catch(Error test){
               System.out.println("Error");
           }catch(Exception test){
               System.out.println("Exception");
           }catch(Throwable test){
               System.out.println("Throwable");
           } finally{
               //finally:处理善后工作，不管是否出现异常，都会执行
               System.out.println("finally");
           }
   
       }
       public void a(){b();}
       public void b(){a();}
   
   
   }
   

package com.exception.demo01;

public class Test02 {
    public static void main(String[] args) {
        int a=1;
       int b=0;
      //选择你要监控的代码，通过Ctrl+Alt+T 快捷键可以快速生成try catch
      // try {
     //      System.out.println(a / b);
     //   } catch (Exception e) {
     //      e.printStackTrace();//打印当前的栈信息
    //   } finally {
     //  }


        try {
            new Test02().test(1, 0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
        
    }
    //假设在方法中，处理不了这个异常，我们可以在方法上抛出
    public void test(int a,int b)throws ArithmeticException {
     //  if(b==0){
           // throw new RuntimeException();//主动抛出异常，一般用在方法中使用
      // }
        System.out.println(a/b);


    }

}

自定义异常

1. 使用Java内置的异常类可以描述在编程时出现的大部分异常，除此之外，用户还可以自定义异常类，只需要继承Exception类即可。

2. 自定义异常分为以下几个步骤

   1. 创建自定义异常类，继承Excption类

   2. 在方法中通过throw关键字抛出异常对象

   3. 可以在方法中直接捕获，也可以用关键字throws在调用方法的时候捕获

      package com.exception.demo02;
      //自定义的异常类
      public class MyException extends Exception {
          //传递一个数字，如果该数字>10，抛出异常
          private int detail;
          //创建一个构造器
          public MyException( int a) {
              this.detail = a;
          }
          //使用toString方法打印异常 信息
      
          @Override
          public String toString() {
              return "MyException{" + "detail=" + detail + '}';
          }
      }
      

package com.exception.demo02;

public class Test {
    public void test(int a)throws MyException{//在调用方法的时候再进行捕获

        if (a>10){
            throw new MyException(a);//主动抛出异常
        }else{
            System.out.println("ok");
        }

    }

    public static void main(String[] args) {
        try {
            new Test().test(11);
        } catch (MyException e) {
            //可以在这里增加一些处理异常的代码块
            System.out.println(e);//打印异常信息  MyException{detail=11}
        }

    }
}

异常在实际应用上面的总结

1. 处理运行异常时，采用逻辑去合理规避同时辅助try-catch进行处理
2. 在多重catch块后面，可以加一个catch(Excpetion)来处理可能被遗漏的异常
3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常
4. 尽量去处理异常
5. 具体如何处理异常，要根据不同业务需求和异常类型去处理
6. 尽量添加finally语句来释放占用的资源