• Java 异常处理机制

    目录

    1.1Java 异常的概念与分类

    1.1.1引入异常（数组越界）

    1.1.2 Throwable

    1.2 Java 异常捕获处理

    1.3 异常处理 finally 语句使用

    1.3.1 引入 finally 关键字

    1.3.2 采用 finally 释放 Scanner 资源

    1.3 Java 异常抛出处理

    1.3.1 主动抛出异常

    1.4 自定义异常类

    1.5 综合案例：

    1.1Java 异常的概念与分类

    1.1.1引入异常（数组越界）

    1. public class TestException {
    2.     /**
    3.      * 会出现 ArrayIndexOutOfBoundsException 异常
    4.      */
    5.     public void method1(){
    6.         String names[] = {"小凳子", "小椅子", "小桌子"};
    7.         for (int i = 0; i < 4; i++) {
    8.             System.out.println(names[i]);
    9.         }
    10.         System.out.println("over");
    11.     }
    12.  
    13.     public static void main(String[] args) {
    14.         TestException te = new TestException();
    15.         te.method1();
    16.     }
    17. }

    1.1.2 Throwable

    异常的最高父类是 Throwable，在 java.lang 包下。

    Throwable 类的构造方法主要有：

    • public Throwable()

      构造一个对象，其错误信息串为 null。

    • public Throwable(String message)

      构造一个对象，其错误信息串为 message。

    Throwable 类的方法主要有：

    方法说明
    public String getMessage()返回对象的错误信息
    public void printStackTrace()输出对象的跟踪信息到标准错误输出流
    public void printStackTrace(PrintStream s)输出对象的跟踪信息到输出流 s
    public String toString()返回对象的简短描述信息

    Exception 类也有很多的子类，提供我们使用

     Throwable 类的子类有 Error 错误和 Exception 违例。Error 错误并不能通过程序代码来解决问题，而 Exception 违例基本是程序员在编写代码时所造成的问题，所以往往我们会将 Error 设为天灾，Exception 设为人祸。

    采用判断语句的方式进行异常的处理，首先必须意识到哪些地方可能出现异常，在可能出现异常的地方加入判断语句和处理代码。这种处理方式对程序员的要求高，因为开发者很难列举出所有的异常发生情况，而且代码量大，程序结构相对混乱。对于此类情况，一种较好的解决方案，就是使用异常处理机制。

    1.2 Java 异常捕获处理

    Java 的异常处理机制中仍体现了面向对象的思想。

    • Java 程序的执行过程中如出现异常，会自动生成一个异常类对象，该异常对象将被提交给 Java 运行时系统，这个过程称为抛出异常。
    • 当 Java 运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获异常。
    • 如果 Java 运行时系统找不到可以捕获异常的方法，则运行时系统将终止，相应的 Java 程序也将退出。

    程序员通常只能处理违例 (Exception) ，而对错误 (Error) 无能为力。

    异常处理机制中已经明确提出需要有代码来处理该异常，而出现异常，系统会自动生成一个异常类对象，这个异常对象是系统生成的，我们无须创建。

    try 和 catch 是关键字，用来处理异常的。该结构中，catch 语句块中一定不要空着，啥都不写，这是一种很危险的情况，如果空着，表示捕获异常，而不做任何处理。

    1. try{
    2.   // 有异常出现的语句，无异常语句也可以放在这个语句块中
    3. }catch(ExceptionClass e){
    4.   // 当产生 ExceptionClass 类型异常时的处置代码
    5. }catch(ExceptionClass2 e){
    6.   // 当产生 ExceptionClass2 类型异常时的处置代码
    7. }catch(ExceptionClassN e){
    8.   // 当产生 ExceptionClassN 类型异常时的处置代码
    9. }]

    try 语句块：

    • 将可能出现异常的代码都放在 try 代码块中。
    • try 语句块中发现异常，剩下的语句将不再执行。

    catch 语句块：

    • 在 catch 语句块中是对异常对象进行处理的代码。
    • 每个 try 语句块可以伴随一个或多个 catch 语句，用于处理可能产生的不同类型的异常对象。
    • 通过 getMessage( ) 获取异常信息或 printStackTrace( ) 跟踪异常信息。
    1. public class TestException {
    2.     public void method1(){
    3.         String names[] = {"小凳子", "小椅子", "小桌子"};
    4.         try {
    5.             for (int i = 0; i < 4; i++) {
    6.                 System.out.println(names[i]);
    7.             }
    8.             System.out.println("over");
    9.         }
    10.         catch (ArrayIndexOutOfBoundsException e){
    11.             System.out.print(e);
    12.         }
    13.  
    14.     }
    15.     public static void main(String[] args) {
    16.         TestException te = new TestException();
    17.         te.method1();
    18.     }
    19. }

            出现异常，系统自动生成 ArrayIndexOutOfBoundsException 异常对象，交给运行时系统，系统去找处理的代码，当匹配到有 catch 的异常是 ArrayIndexOutOfBoundsException 时，就进入 catch 语句块，本次处理方式是打印异常对象，就是调用 toString() 方法返回对象的简短描述信息。使用 catch 语句块，异常对象捕获到一个匹配的 catch ，将不会再考虑其他了

    ArithmeticException 数学计算异常（如出现分母为0）

    NumberFormatException 数字格式异常（如输入数字时输入字符串）

    InputMismatchException 输入不匹配

    1. public class TestException {
    2.     public void method2(String a,String b){
    3.         double c = 0.0;
    4.         try{
    5.             c = Integer.parseInt(a) / Integer.parseInt(b);
    6.         }catch(ArithmeticException e){
    7.             System.out.println(e.getMessage());
    8.         }catch(NumberFormatException e){
    9.             e.printStackTrace();
    10.         }
    11.         System.out.println(c);
    12.     }
    13.     public static void main(String[] args) {
    14.         TestException te = new TestException();
    15.         te.method2(args[0], args[1]);
    16.     }
    17. }

    最简化的书写方式，也可以这样写，它们都是 Exception 子类。

    1. public class TestException {
    2.  
    3.     public void method3(String a,String b){
    4.         double c = 0.0;
    5.         try{
    6.             c = Integer.parseInt(a) / Integer.parseInt(b);
    7.         }catch(Exception e){
    8.             System.out.println(e.getMessage());
    9.         }
    10.         System.out.println(c);
    11.     }
    12.     public static void main(String[] args) {
    13.         TestException te = new TestException();
    14.         te.method3(args[0], args[1]);
    15.     }
    16. }

    1.3 异常处理 finally 语句使用

    1.3.1 引入 finally 关键字

    之前我们学过的是 final 关键字，而现在需要来学习的 finally 关键字。

    finally 关键字主要是和捕获异常的 try-catch 语句一起使用，放在 finally 语句块中的内容表示无条件执行的部分，也就是说不管程序有异常或没有异常都需要执行的部分。

    1. try{
    2.     // 可能产生异常的代码
    3. }catch( ExceptionClass1 e ){
    4.     // 当产生 ExceptionName1 类型异常时的处置措施
    5. }catch( ExceptionClass2 e ){
    6.     // 当产生ExceptionName2型异常时的处置措施
    7. }finally{
    8.     // 无条件执行的语句
    9. }

    运行时异常：编译的时候都是没有问题，但是运行时会出现异常

    RuntimeException 是所有运行时异常的父类，API 如下图：

     而实际中有许多都是在编译时会提示需要进行异常处理，否则编译将不能通过。如：

    我们可以通过 SimpleDateFormat 类调用 format() 方法来进行日期格式化操作

    同时对于以上的代码，我们应该完成转换操作之后，将 SimpleDateFormat 资源进行释放。你就应该要想到的是 finally 语句，无论是否有异常存在，都应该执行的部分，因为它是无条件执行语句块。

    企业面试时，经常会提到的问题：final、finally 和 finalize 的区别是什么？

    • final 关键字，是用来修饰属性、方法、类的。
    • finally 关键字，可以配合异常处理，进行无条件执行操作。
    • finalize 不是关键字，是 Object 类中的一个方法，是 Java 垃圾回收机制中进行资源释放的方法。

    1.3.2 采用 finally 释放 Scanner 资源

    为了避免造成大量的内存占据，我们需要将不在使用的内存空间得到及时的释放。方法结束后，Scanner 对象虽然会进入被回收的队列中，但不是立刻回收，而这会给计算机带来一定的负担。

    Java处理InterruptedException异常的理论与实践
    pdf 0星 超过10%的资源 106KB
    下载
    1. import java.util.InputMismatchException;
    2. import java.util.Scanner;
    3.  
    4. public class DivideApples {
    5.     //苹果数
    6.     int appleNum = 0;
    7.     //学生数
    8.     int stuNum = 0;
    9.     public void divide() {
    10.         System.out.println("**_现在给孩子们分苹果_**");
    11.         Scanner input = new Scanner(System.in);
    12.         try{
    13.             System.out.print("请输入桌子上有几个苹果：");
    14.             appleNum = input.nextInt();
    15.             System.out.print("请输入班上有几个孩子：");
    16.             stuNum = input.nextInt();
    17.             System.out.println("班上每个孩子分得多少苹果：" + appleNum / stuNum);
    18.             System.out.println("孩子们非常开心！");
    19.         }
    20.         catch (InputMismatchException e){
    21.             System.out.print("苹果数量和孩子人数必须为整数值！");
    22.         }catch (ArithmeticException e){
    23.         System.out.print("孩子人数不能为零！");
    24.         }finally {
    25.             input.close();
    26.             System.out.print("Scanner 对象进行释放");
    27.         }
    28.     }
    29.     public static void main(String[] args) {
    30.         new DivideApples().divide();
    31.     }
    32. }

    1.3 Java 异常抛出处理

    异常的另一种处理方式，便是抛出异常，需要使用关键字 throws 。throws 抛出的异常可以是 0 或多个，也就是说·可以抛出 1 个，或多个。

    知道会出现错误直接抛出不处理，由调用该方法的对象处理（try-catch)，也可以提醒别人。

    1. public void method2(String a,String b) throws ArithmeticException, NumberFormatException{
    2.     double c = Integer.parseInt(a) / Integer.parseInt(b);
    3.     System.out.println(c);
    4. }

    当然你也可以采用最简化的抛出方式：

    1. public void method3(String a,String b) throws Exception{
    2.         double c = Integer.parseInt(a) / Integer.parseInt(b);
    3.         System.out.println(c);
    4. }

    直接抛出 Exception，就不用一个个的抛出了，当然从规范的角度来说，在企业项目中，还是需要确切到具体的异常类。

    1.  
    2. public class TestException4{
    3.     /**
    4.      * 采用异常抛出处理方式进行数组下标越界处理
    5.      * @throws ArrayIndexOutOfBoundsException 数组下标越界异常
    6.      */
    7.     public void method1() throws ArrayIndexOutOfBoundsException{
    8.         String names[] = {"小凳子", "小椅子", "小桌子"};
    9.         for (int i = 0; i < 4; i++) {
    10.             System.out.println(names[i]);
    11.         }
    12.         System.out.println("over");
    13.     }
    14.  
    15.     /**
    16.      * 采用异常抛出处理方式进行数学计算和数字格式化处理
    17.      * @param a 命令行参数
    18.      * @param b 命令行参数
    19.      * @throws ArithmeticException 数学计算异常
    20.      * @throws NumberFormatException 数字格式化异常
    21.      */
    22.     public void method2(String a,String b) throws ArithmeticException, NumberFormatException{
    23.         double c = Integer.parseInt(a) / Integer.parseInt(b);
    24.         System.out.println(c);
    25.     }
    26.  
    27.     /**
    28.      * 采用最简化的方法抛出异常处理
    29.      * @param a 命令行参数
    30.      * @param b 命令行参数
    31.      * @throws Exception 包含了所有的异常
    32.      */
    33.     public void method3(String a,String b) throws Exception{
    34.         double c = Integer.parseInt(a) / Integer.parseInt(b);
    35.         System.out.println(c);
    36.     }
    37.  
    38.     public static void main(String[] args) {
    39.         TestException4 te = new TestException4();
    40.         // 调用 method1 方法进行异常处理
    41.         try{
    42.             te.method1();
    43.         }catch(ArrayIndexOutOfBoundsException e){
    44.             System.out.println(e);
    45.         }
    46.         // 调用 method2 方法进行异常处理
    47.         try {
    48.             te.method2(args[0], args[1]);
    49.         } catch (ArithmeticException e) {
    50.             e.printStackTrace();
    51.         } catch (NumberFormatException e){
    52.             e.printStackTrace();
    53.         }
    54.         // 调用 method3 方法进行异常处理
    55.         try {
    56.             te.method3(args[0], args[1]);
    57.         } catch (Exception e) {
    58.             e.printStackTrace();
    59.         }
    60.     }
    61. }

    1.3.1 主动抛出异常

            之前讲到异常处理机制，当系统发现有异常，会自动产生一个异常对象，然后交给运行时系统，这叫抛出异常；主动抛出异常，那就是不需要系统生成异常对象，而是我们在编写代码时，对于可能会出现异常的部分，自己创建异常对象将它抛出，这就是主动抛出异常。

    主动抛出异常，其实是希望提供更明确的异常提示信息。

    语法结构：

    throw new 异常类(message);

            注意：这里是 throw 而不是 throws，有很多同学会搞混 throw 和 throws，你只需要记住一点，throw 关键字后只能抛出一个确切的异常类对象，而 throws 后可以抛出多个异常类，而非 new 的对象。

    1. /**
    2.  * 使用 throw 主动抛出异常
    3.  */
    4. public class TestException5 {
    5.     /**
    6.      * throw 和 throws 配置使用
    7.      * @throws Exception 异常类
    8.      */
    9.     public void method1() throws Exception{
    10.         String names[] = {"小凳子", "小椅子", "小桌子"};
    11.         for (int i = 0; i < 4; i++) {
    12.             if(i > names.length-1){
    13.                 throw new ArrayIndexOutOfBoundsException("数组下标越界异常:数组元素提取下标为 " + i + "，超出数组取值范围！");
    14.             }
    15.             System.out.println(names[i]);
    16.         }
    17.         System.out.println("over");
    18.     }
    19.     /**
    20.      * throw 和 try-catch 配置使用
    21.      * @param a 命令行参数
    22.      * @param b 命令行参数
    23.      */
    24.     public void method2(String a,String b){
    25.         double c = 0.0;
    26.         try{
    27.             int a1 = Integer.parseInt(a);
    28.             if(a1 == 0){
    29.                 throw new RuntimeException("第一个参数为 0 ，除法计算永远都是零");
    30.             }
    31.             int b1 = Integer.parseInt(b);
    32.             if(b1 == 0){
    33.                 throw new ArithmeticException("除数不能为零");
    34.             }
    35.             c = a1 / b1;
    36.         }catch(ArithmeticException e){
    37.             System.out.println(e);
    38.         }catch(NumberFormatException e){
    39.             e.printStackTrace();
    40.         }catch(RuntimeException e){
    41.             System.out.println(e.getMessage());
    42.         }
    43.         System.out.println(c);
    44.     }
    45.  
    46.     public static void main(String[] args) {
    47.         TestException5 te = new TestException5();
    48.         // 调用 mehtod1 方法进行异常处理
    49.         try {
    50.             te.method1();
    51.         } catch (Exception e) {
    52.             System.out.println(e.getMessage());
    53.         }
    54.         // 调用 method2 方法
    55.         te.method2(args[0], args[1]);
    56.     }
    57. }

    方法重写的要求吗？

    1. 方法名、返回类型、参数列表必须相同。
    2. 方法的修饰符范围可以相同或更大。

    我们可以发现，throws 是不是在方法上声明的，对吧 ~ 🙂

    那么方法的重写需要加上第三个要求，抛出的异常要么和父类一样，或是父类抛出异常的子类，但是不能是抛出异常的父类。

    父类 ClassA 中的 method() 方法：

    1. public void method() throws ArithmeticException, NumberFormatException{
    2.  
    3. }

    子类 ClassB 中重写父类 method() 方法：

    可以只抛出父类中的一个异常类。

    1. public void method() throws ArithmeticException{
    2.  
    3. }

    或是

    1. public void method() throws NumberFormatException{
    2.  
    3. }

    或是

    1. public void method() throws ArithmeticException,NumberFormatException{
    2.  
    3. }

    不抛出异常类也是可以的。

    1. public void method(){
    2.  
    3. }
    Java中的异常和处理机制实例详解
    pdf 0星 超过10%的资源 184KB
    下载

    但是抛出的异常不能大于父类抛出的异常，则是错误的。

    1. public void method() throws Exception{
    2.  
    3. }
    1. 学会使用 throw 和 throws 关键字进行异常操作。
    2. throws 在方法声明的同时抛出异常，可以到调用方法时再进行处理。
    3. throw 主动抛出异常对象，可以传递更为确切的异常信息。
    4. 当子类重写父类方法时，需要考虑抛出的异常类，可以相同或是子类，但是不能更大。


    1.4 自定义异常类

    我们简单的复习一下：

    异常处理机制，当发现异常，系统将自动生成异常类对象，然后抛出异常交给运行时系统，系统查找是否有可以处理该异常的代码，找到匹配的 catch ，将异常交给它处理即可，如果找不到处理的代码，那么程序将被迫停止。

    异常处理的两种方式：

    • 捕获异常，采用 try-catch 语句。
    • 抛出异常，采用 throws 在方法声明中抛出。

    当 API 中提供的异常类不能满足你的需求时，需要自定义异常类。

    还有一种情况是，在企业项目中，可以更明确异常位置和信息，我们需要自定义异常类。

    自定义异常类，其实很简单，只需满足以下两个要求即可：

    1. 声明一个类需要继承 Exception 或是它的子类。
    2. 提供至少 2 个构造方法，一个无参构造器，一个带参构造器，参数需要包含传递的异常信息。

    语法结构：

    1. [public] class 类名 extends Exception 或是 Exception 子类{
    2.       // 无参构造器
    3.     public 类名(){
    4.       // 不传递默认异常信息也是可以的
    5.       super("传递默认的异常信息");
    6.     }
    7.  
    8.       public 类名(String messag[, 参数类型 参数名 ...]){
    9.       // 通过父类带一个参数的构造器，传递异常信息
    10.       super(message);
    11.       // 其他数据传递操作，和之前要求的是一样的
    12.     }
    13. }

    注意：对于异常类的类名，一般我们在命名时，可以根据作用功能进行命名，后缀加上 Exception，如：「AgeException」、「PersonException」等等。

    判断数组是否为空，如果为空给出异常提示信息。

    1. class ArrayIsNullException extends Exception{
    2.       // 无参构造器
    3.     public ArrayIsNullException(){
    4.         super("ArrayIsNullException: 数组长度为 0");
    5.     }
    6.       // 带参构造器
    7.     public ArrayIsNullException(String message){
    8.         super(message);
    9.     }
    10. }

    使用自定义异常类：

    1. public int method1(int[] arrays, int index){
    2.     if(arrays.length == 0){
    3.       throw new ArrayIsNullException();
    4.     }
    5.     return arrays[index];
    6. }

    编译后报错提示我们必须对其进行捕获或声明以便抛出。

    修改后:

    1. /**
    2.  * 自定义异常类的使用
    3.  */
    4. public class TestException6 {
    5.  
    6.    
    7.     public void method1(int[] arrays, int index) throws ArrayIsNullException {
    8.         if (arrays.length == 0) {
    9.             //throw new ArrayIsNullException();
    10.             throw new ArrayIsNullException("数组为空，提取不到下标 " + index + " 的数组元素。");
    11.         }
    12.         System.out.println(arrays[index]);
    13.     }
    14.  
    15.     public static void main(String[] args) {
    16.         TestException6 te = new TestException6();
    17.         try {
    18.             te.method1(new int[] {}, 2);
    19.         } catch (ArrayIsNullException e) {
    20.             System.out.println(e.getMessage());
    21.         }
    22.     }
    23. }
    24.  
    25. // 自定义异常类
    26. class ArrayIsNullException extends Exception{
    27.  
    28.     /**
    29.      * 无参构造器，传递默认异常信息
    30.      */
    31.     public ArrayIsNullException(){
    32.         super("ArrayIsNullException: 数组长度为 0");
    33.     }
    34.  
    35.     /**
    36.      * 带异常信息的构造器
    37.      * @param message 异常信息
    38.      */
    39.     public ArrayIsNullException(String message){
    40.         super(message);
    41.     }
    42. }

    本实验主要学习自定义异常类，并结合 try-catch 语句和 throws 抛出异常处理。

    创建异常类，只需满足以下两个要求：

    1. 声明一个类需要继承 Exception 或是它的子类。
    2. 提供至少 2 个构造方法，一个无参构造器，一个带参构造器，参数需要包含传递的异常信息。

    1.5 综合案例：

    姓名要求输入不少于 1 个字符且不超过 20 个字符，否则应该抛出异常；年龄只能输入为 18 ~ 35 的 int 类型数字，否则应该抛出异常；性别只能输入 1 或 2 进行选择，否则应该抛出异常，抛出异常后应提示“请重新输入”，并且可以重新输入当前信息。

    1. import java.util.Scanner;
    2.  
    3. public class Registration extends Exception{
    4.  
    5.     public Registration()  {
    6.         super();
    7.     }
    8.  
    9.     public Registration(String message) {
    10.         super(message);
    11.     }
    12.  
    13.     public static Scanner input = new Scanner(System.in);
    14.  
    15.     public static void main(String[] args) {
    16.  
    17.         System.out.println("请输入您的姓名(不小于 1 个字符且不超过 20 个字符)：");
    18.         String name = new String();
    19.         do{
    20.             try {
    21.                 name = inputName();
    22.             } catch (Registration e) {
    23.                 System.out.println(e.getMessage());
    24.             }
    25.         }while ((name.length()<1)||(name.length()>20));
    26.  
    27.         System.out.println("请输入您的年龄(18~35)：");
    28.         int age = 0;
    29.         do{
    30.             try {
    31.                 age = inputAge();
    32.             } catch (Registration e) {
    33.                 System.out.println(e.getMessage());
    34.             }
    35.         }while (age<18||age>35);
    36.  
    37.  
    38.         System.out.println("请选择您的性别：1. 男    2. 女");
    39.         String gender = new String();
    40.         do{
    41.             try {
    42.                 gender = setGender();
    43.             } catch (Registration e) {
    44.                 System.out.println(e.getMessage());
    45.             }
    46.         }while (!gender.equals("男")&&!gender.equals("女"));
    47.  
    48.  
    49.         System.out.println("您的报名信息为： 姓名：" + name + "；年龄：" + age + "；性别：" + gender);
    50. }
    51.  
    52.     /**
    53.      * 输入姓名的方法
    54.      */
    55.     public static String inputName() throws Registration {
    56.         String name=null;
    57.  
    58.         name=input.next();
    59.         if(name.length()>=1&&name.length()<=20){
    60.             return name;
    61.         }
    62.         else {
    63.             throw new Registration("你输入的姓名长度不符合要求，请重新输入：");
    64.         }
    65.     }
    66.  
    67.     /**
    68.      * 输入年龄的方法
    69.      */
    70.     public static int inputAge() throws Registration {
    71.         // 补充代码
    72.         int age=input.nextInt();
    73.         if(age>=18&&age<=35){
    74.             return age;
    75.         }
    76.         else {
    77.             throw new Registration("年龄设置为"+age+"不符合要求，请重新输入：");
    78.         }
    79.     }
    80.  
    81.     /**
    82.      * 选择性别的方法
    83.      */
    84.     public static String setGender() throws Registration {
    85.         // 补充代码
    86.         String gender=input.next();
    87.         if(gender.equals("1")){
    88.             return "男";
    89.         }
    90.         else if(gender.equals("2")){
    91.             return "女";
    92.         }
    93.         else {
    94.             throw new Registration("请输入1或2选择你的性别，请重新输入：");
    95.         }
    96.     }
    97.  
    98.     // 内部异常类
    99.     // 补充代码
    100.  
    101. }

  • 相关阅读:
    MySQL进阶一 一条select语句的执行流程
    vscode 常用插件
    上传ipa到appstore最简单的方法
    文件MultipartFile上传同时，接收复杂参数
    Tomcat配置SSL证书别名tomcat无法识别密钥项
    springboot中如何同时操作同一功能
    【博学谷学习记录】超强总结，用心分享|SSH免密登录|附带自动脚本
    SPASS-指数平滑法
    MYSQL06高级_为什么使用索引、优缺点、索引的设计、方案、聚簇索引、联合索引、注意事项
    物流职业怎么运用自动化员工保证清算效率
  • 原文地址：https://blog.csdn.net/qq_58631644/article/details/125980678