1、异常概述与异常体系结构

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

1、什么是异常?

在Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)

2、异常的分类

Java程序在执行过程中所发生的异常事件可分为两类：
Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。
Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：

  • 空指针访问
  • 试图读取不存在的文件
  • 网络连接中断

  • 数组角标越界

    3、解决办法

  • 一是遇到错误就终止程序的运行。

  • 另一种方法是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

异常分类：编译时异常和运行时异常
运行时异常

  • 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
  • 对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

编译时异常

  • 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
  • 对于这类异常，如果程序不处理，可能会带来意想不到的结果。

2、异常的处理方式

1、异常处理机制一：try-catch-finally

Java异常处理的方式: try-catch-finally

  • try
    • 捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。
  • catch(Exceptiontypee)
  • 在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
  • 捕获异常的有关信息：与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
    • getMessage() 获取异常信息，返回字符串
    • printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

image.png

  • finally
    • 捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
    • 不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。
    • finally语句和catch语句是任选的

image.png
说明:

  • finally是可选的。
  • 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配。
  • 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况）。继续执行其后的代码。
  • catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
  • catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
  • 常用的异常对象处理的方式： ① String getMessage() ② printStackTrace()
  • 在try结构中声明的变量，再出了try结构以后，就不能再被调用,例65行:System.out.println(num);
  • try-catch-finally结构可以嵌套

使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.IOException;
  6. import org.junit.Test;
  8. /*
  9.  * 异常的处理:抓抛模型
  10.  * 
  11.  * 过程一:“抛”：程序在征程执行过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象
  12.  *              并将此对象抛出。
  13.  *             一旦抛出对象以后，其后的代码就不再执行。
  14.  * 
  15.  * 过程二:“抓”:可以理解为异常的处理方式：① try-catch-finally  ② throws
  16.  * 
  17.  * 二、try-catch-finally的使用
  18.  * 
  19.  * try{
  20.  *         //可能出现异常的代码
  21.  * }catch(异常类型1 变量名1){
  22.  *         //处理异常的方式1
  23.  * }catch(异常类型2 变量名2){
  24.  *         //处理异常的方式2
  25.  * }catch(异常类型3 变量名3){
  26.  *         //处理异常的方式3
  27.  * }
  28.  * ...
  29.  * finally{
  30.  *         //一定会执行的代码
  31.  * }
  32.  * 
  33.  * 说明:
  34.  * 1.finally是可选的。
  35.  * 2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象
  36.  *   的类型，去catch中进行匹配。
  37.  * 3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的
  38.  *   try-catch结构（在没有写finally的情况）。继续执行其后的代码。
  39.  * 4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
  40.  *   catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
  41.  * 5.常用的异常对象处理的方式： ① String  getMessage()    ② printStackTrace()
  42.  * 6.在try结构中声明的变量，再出了try结构以后，就不能再被调用,例65行:System.out.println(num);
  43.  * 7.try-catch-finally结构可以嵌套  
  44.  * 
  45.  * 体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。
  46.  *     相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
  47.  *     
  48.  * 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。
  49.  *      针对于编译时异常，我们说一定要考虑异常的处理。
  50.  */
  51. public class ExceptionTest1 {
  53.     @Test
  54.     public void test2(){
  55.         try{
  56.             File file = new File("hello.txt");
  57.             FileInputStream fis = new FileInputStream(file);
  59.             int data = fis.read();
  60.             while(data != -1){
  61.                 System.out.print((char)data);
  62.                 data = fis.read();
  63.             }
  65.             fis.close();
  66.         }catch(FileNotFoundException e){
  67.             e.printStackTrace();
  68.         }catch(IOException e){
  69.             e.printStackTrace();
  70.         }
  71.     }
  73.     @Test
  74.     public void test1(){
  76.         String str = "123";
  77.         str = "abc";
  78.         try{
  79.             int num = Integer.parseInt(str);    
  81.             System.out.println("hello-----1");
  82.         }catch(NumberFormatException e){
  83. //            System.out.println("出现数值转换异常了，不要着急....");
  84.             //String getMessage():
  85. //            System.out.println(e.getMessage());
  86.             //printStackTrace():
  87.             e.printStackTrace();
  88.         }catch(NullPointerException e){
  89.             System.out.println("出现空指针异常了，不要着急....");
  90.         }catch(Exception e){
  91.             System.out.println("出现异常了，不要着急....");
  92.         }
  93. //        System.out.println(num);
  95.         System.out.println("hello----2");
  96.     }
  97. }

1、finally的使用

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.IOException;
  6. import org.junit.Test;
  8. /*
  9.  * try-catch-finally中finally的使用：
  10.  * 
  11.  * 1.finally是可选的。
  12.  * 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有
  13.  *   return语句等情况。
  14.  * 3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的
  15.  *   释放。此时的资源释放，就需要声明在finally中。
  16.  * 
  17.  */
  18. public class FinallyTest {
  20.     @Test
  21.     public void test2() {
  22.         FileInputStream fis = null;
  23.         try {
  24.             File file = new File("hello1.txt");//文件可能不存在，而出现异常
  25.             fis = new FileInputStream(file);
  27.             int data = fis.read();
  28.             while (data != -1) {
  29.                 System.out.print((char) data);
  30.                 data = fis.read();
  31.             }
  33.         } catch (FileNotFoundException e) {
  34.             e.printStackTrace();
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         } finally {
  38.             try {
  39.                 if (fis != null)
  40.                     fis.close();
  41.             } catch (IOException e) {
  42.                 e.printStackTrace();
  43.             }
  44.         }
  45.     }
  47.     @Test
  48.     public void testMethod() {
  49.         int num = method();
  50.         System.out.println(num);
  51.     }
  53.     public int method() {
  55.         try {
  56.             int[] arr = new int[10];
  57.             System.out.println(arr[10]);
  58.             return 1;
  59.         } catch (ArrayIndexOutOfBoundsException e) {
  60.             e.printStackTrace();
  61.             return 2;
  62.         } finally {
  63.             System.out.println("我一定会被执行");
  64.             return 3;
  65.         }
  66.     }
  68.     @Test
  69.     public void test1() {
  70.         try {
  71.             int a = 10;
  72.             int b = 0;
  73.             System.out.println(a / b);
  74.         } catch (ArithmeticException e) {
  75.             // e.printStackTrace();
  77.             int[] arr = new int[10];
  78.             System.out.println(arr[10]);
  80.         } catch (Exception e) {
  81.             e.printStackTrace();
  82.         }
  83.         // System.out.println("我好慢呀~~~");
  84.         finally {
  85.             System.out.println("我好慢呀~~~");
  86.         }
  87.     }
  88. }

2、异常处理机制二：throws

  • 声明抛出异常是Java中处理异常的第二种方式
    • 如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

  • 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。 ```java /*

    • 异常处理的方式二：throws + 异常类型
      1. “throws + 异常类型”写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
    • 一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常
    • 类型时，就会被抛出。异常代码后续的代码，就不再执行！ *
    • 关于异常对象的产生:① 系统自动生成的异常对象
    • ② 手动生成一个异常对象，并抛出(throw)
      1. 体会：try-catch-finally:真正的将异常给处理掉了。
    • throws的方式只是将异常抛给了方法的调用者。 并没有真正将异常处理掉。

    • */ public class ExceptionTest2 {

      public static void main(String[] args){

      1. try {
      2.     method2();
      3. } catch (IOException e) {
      4.     e.printStackTrace();
      5. }
      7. method3();

      }

      public static void method3(){

      1. try {
      2.     method2();
      3. } catch (IOException e) {
      4.     e.printStackTrace();
      5. }

      }

      public static void method2() throws IOException{

      1. method1();

      }

  1. public static void method1() throws FileNotFoundException,IOException{
  2.     File file = new File("hello1.txt");
  3.     FileInputStream fis = new FileInputStream(file);
  5.     int data = fis.read();
  6.     while(data != -1){
  7.         System.out.print((char)data);
  8.         data = fis.read();
  9.     }
  11.     fis.close();
  13.     System.out.println("hahaha!");
  14. }

}

  1. <a name="gOlwk"></a>
  2. # 3、开发中如何选择使用try-catch-finally 还是使用throws
  4. - 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
  5. - 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws 的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。
  6. <a name="Hxs5U"></a>
  7. # 4、手动抛出异常
  8. Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。
  10. - 首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)
  11. - 可以抛出的异常必须是Throwable或其子类的实例。
  12. ```java
  13. public class StudentTest {
  14.     public static void main(String[] args) {
  15.         try {
  16.             Student s = new Student();
  17. //        s.regist(1001);
  18.             s.regist(-1001);
  19.             System.out.println(s);
  20.         } catch (Exception e) {
  21. //            e.printStackTrace();
  22.             System.out.println(e.getMessage());
  23.         }
  24.     }
  25. }
  26. class Student{
  27.     private int id;
  29.     public void regist(int id) throws Exception{
  30.         if(id > 0){
  31.             this.id = id;
  32.         }else{
  33. //            System.out.println("您输入的数据非法！");
  34.             //手动抛出异常
  35. //            throw new RuntimeException("您输入的数据非法！");
  36.             throw new Exception("您输入的数据非法！");
  38.         }
  39.     }
  41.     @Override
  42.     public String toString() {
  43.         return "Student [id=" + id + "]";
  44.     }
  46. }

5、用户自定义异常类

  • 一般地，用户自定义异常类都是RuntimeException的子类。
  • 自定义异常类通常需要编写几个重载的构造器。
  • 自定义异常需要提供serialVersionUID
  • 自定义的异常通过throw抛出。

  • 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。 ```java /*

    • 如何自定义异常类？
    • 1.继承于现有的异常结构：RuntimeException 、Exception
    • 2.提供全局常量：serialVersionUID
    • 3.提供重载的构造器

    • */ public class MyException extends RuntimeException{ static final long serialVersionUID = -7034897193246939L;

      public MyException(){

      }

      public MyException(String msg){

      1. super(msg);

      } }

``` image.png