第7章 异常机制

7.1 异常及体系结构

7.1.1 什么是异常

1. 异常指的是程序运行过程中出现的不期而至的各种状况，比如：文件找不到、网络连接失败、非法参数等。

2. 异常发生在程序的运行期间，它影响了正常的程序执行流程。

7.1.2 简单分类

根据Java异常处理的工作原理分为

1. 检查异常

   • 最具代表的检查性异常是用户错误或问题引发的异常，这是程序员无法预见的。

2. 运行时异常

   运行异常是可能被程序员避免的异常。与检查性异常相反，运行异常可以在编译时被忽略。

3. 错误ERROR

   错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。

7.1.3 异常体系结构

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

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

7.1.4 ERROR

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

2. Java虚拟机运行异常（Virtual MachineError），当JJVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生的时候，java虚拟机一般会选择线程终止。

3. 还有发生在虚拟机试图执行应用时，如类定义错误、连接错误等。

7.1.5 Exception

1. Exception 异常主要分为两类

   • 一类是 IOException（I/O 输入输出异常），其中 IOException 及其子类异常又被称作「受查异常」

   • 另一类是 RuntimeException（运行时异常），RuntimeException 被称作「非受查异常」。

   • 注意

     受查异常就是指，编译器在编译期间要求必须得到处理的那些异常，你必须在编译期处理了。

2. 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

7.2 Java异常处理机制

1. 抛出异常

   • 当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

   • 方法：抛出异常的方法：throws和throw

     public class Shoot {
         static void pop()throws NegativeArraySizeException{
             int[] arr = new int[-3];
         }
         public static void main(String[] args) {
              try{
                  pop();
              }catch(NegativeArraySizeException e){
                  System.out.println("pop()方法抛出的异常");
              }
         }
      
     }

      

2. 捕获异常

   • 在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。

   • 捕捉异常通过try-catch语句或者try-catch-finally语句实现。

   • 可以不用finally，他一般处理善后工作。

   • 实例

     package Exception;
      
     public class exception4 {
         public exception4() {
         }
      
         boolean testEx() throws Exception {
             boolean ret = true;
             try {//监控区
                 ret = testEx1();
             } catch (Exception e) {//捕获异常
                 System.out.println("testEx, catch exception");
                 ret = false;
                 throw e;
             } finally {//善后工作
                 System.out.println("testEx, finally; return value=" + ret);
                 return ret;
             }
         }
      
         boolean testEx1() throws Exception {
             boolean ret = true;
             try {
                 ret = testEx2();
                 if (!ret) {
                     return false;
                 }
                 System.out.println("testEx1, at the end of try");
                 return ret;
             } catch (Exception e) {
                 System.out.println("testEx1, catch exception");
                 ret = false;
                 throw e;
             } finally {
                 System.out.println("testEx1, finally; return value=" + ret);
                 return ret;
             }
         }
      
         boolean testEx2() throws Exception {
             boolean ret = true;
             try {
                 int b = 12;
                 int c;
                 for (int i = 2; i >= -2; i--) {
                     c = b / i;
                     System.out.println("i=" + i);
                 }
                 return true;
             } catch (Exception e) {
                 System.out.println("testEx2, catch exception");
                 ret = false;
                 throw e;
             } finally {
                 System.out.println("testEx2, finally; return value=" + ret);
                 return ret;
             }
         }
      
         public static void main(String[] args) {
             exception4 testException1 = new exception4();
             try {
                 testException1.testEx();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }

      

3. 异常处理的五个关键字：

   • try、catch、finally、throw、throws

7.3 自定义异常

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

2. 在程序中使用自定义异常类中，大体可以分为以下几个步骤：

   • 创建自定义异常类

   • 在方法中通过throw关键字来抛出异常对象。

   • 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字知名要跑出给方法调用者的异常，继续执行下一步操作。

   • 在出现异常方法的调用者中捕获异常并处理异常。

3. 实例

   package Demo031;
   ​
   /**
    * @Author: H-YONG-8
    * @DATA: 2023/4/19
    * JavaSE
    * 自定义异常类
    */
   public class MyException extends Exception{
       //传递数字
       private int detail;
   ​
       public MyException(int a){
           this.detail = a;
       }
   ​
       //toString 异常的打印信息
   ​
       @Override
       public String toString() {
           return "MyException{" +
                   "detail=" + detail +
                   '}';
       }
   }
   ​
   ​
   package Demo031;
   ​
   /**
    * @Author: H-YONG-8
    * @DATA: 2023/4/19
    * JavaSE
    */
   public class Test {
   ​
       //可能会存在的异常方法
   ​
       static void test(int a) throws MyException {
           if (a>10){
               throw new MyException(a);
           }
           System.out.println("OK");
       }
   ​
       public static void main(String[] args){
           try {
               test(11);
           }catch (MyException e){
               System.out.println("myexception=>"+e);
           }
       }
   }
   ​

7.4 总结应用中的实际异常

1. 处理运行异常的时候，采用逻辑去合理的规避同时辅助try-catch处理

2. 在多重catch块后面，可以加一个catch（Exception）来处理可能被遗忘的异常

3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常

4. 尽量去处理异常，切记只是简单调用printStackTrace（）去打印输出

5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定

6. 尽量添加finally语句块去释放占用的资源。