Java基础笔记（八）【异常】

异常的分类

1. 三种类型的异常：

   • 检查性异常：最具代表性的就是用户错误或问题引起的异常，是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
   • 运行时异常：可能被程序员避免的异常。与检查性异常相反，可以在编译时被忽略。
   • 错误ERROR：不是异常，是脱离程序员控制的问题，在代码中通常被忽略。如：栈溢出时，一个错误就产生了，在编译也检查不到。

2. 异常体系结构

   • Java把异常当作对象来处理，并定义一个基类：java.lang.Throwable作为所有异常的超类。

   • 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误ERROR和异常Exception。

     

3. Error：

4. Exception：
   

5. 异常处理机制

   • 抛出异常
   • 捕获异常

6. 异常处理的5个关键字：

   try、catch、finally、throw、throws

   public class Test {
       public static void main(String[] args) {
           int a = 1;
           int b = 0;
   
           try {
               //监控区域
               System.out.println(a/b);
           }catch (ArithmeticException e){
               //捕获异常
               System.out.println("程序出现异常，变量b不能被a整除");
           }finally {
               //处理善后工作
               System.out.println("finally");
           }
       }
   }
   

   //输出
   程序出现异常，变量b不能被a整除
   finally
   

   如果不用try catch，程序会出现异常：java.lang.ArithmeticException: / by zero

   这里可以不用finally，但是设计一些IO流，需要关闭资源等情况下需要用finally。

   ERROR如果用try catch捕获了也没用，但finally仍会执行。能不能捕获，取决于catch后填入的参数，填入最高参数Throwable一定会被捕获。

   可以写多个catch，层层递进，将最大的写在最后。即，从小到大去捕获。与if else类似，只要一个catch执行了，其他就不会执行了。

   public class Demo01 {
       public static void main(String[] args) {
           try {
               new Demo01().a();
           }catch (Exception e){
               System.out.println("exception");
           }catch (Error error){
               System.out.println("error");
           }catch (Throwable throwable){
               System.out.println(throwable);
           }finally {
               System.out.println("善后工作");
           }
       }
       public void a(){
           b();
       }
       public void b(){
           a();
       }
   }
   

   //输出
   error
   善后工作
   

   • 快捷键：ctrl+alt+T

     选中想要try catch的语句后，按下快捷键，会自动将其包裹起来

     

   public class Demo02 {
       public static void main(String[] args) {
           int a = 1;
           int b = 0;
           try {
               System.out.println(a/b);
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
           }
       }
   }
   

   java.lang.ArithmeticException: / by zero
   	at com.exception.Demo02.main(Demo02.java:14)
   

   • 假设方法中处理不了异常，就需要在方法上抛出异常。

   public class Demo03 {
   
       public static void main(String[] args) {
           try {
               new Demo03().test(1,0);
           } catch (ArithmeticException e) {
               e.printStackTrace();
           } finally {
           }
       }
   
       public void test(int a, int b)throws ArithmeticException{
           if (b == 0){
               throw new ArithmeticException();
           }
           System.out.println(a/b);
       }
   }
   

自定义异常

7. 自定义异常

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

   在程序中使用自定义异常类，可以分一下几个步骤。

   1. 创建自定义异常类。
   2. 在方法中通过throw关键字抛出异常对象。
   3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
   4. 在出现异常方法的调用者中捕获并处理异常。

处理异常

8. 处理异常
   • 处理运行时异常时，采用逻辑去合理规避，同时辅助try-catch处理。
   • 在多重catch块后，可以加一个catch(Exception)来处理可能会被遗漏的异常。
   • 对于不确定的代码，也可以加上try-catch，处理潜在的异常。
   • 尽量去处理异常，切忌知识简单地调用printStackTrace()去打印输出，可以增加一些处理异常的代码块。
   • 具体如何处理异常，要根据不同业务需求和异常类型去决定。
   • 尽量添加finally语句块去释放占用的资源。