Java常用工具之异常

Java常用工具之异常

一、异常分类

在程序开发中，异常指不期而至的各种状况。它是一个事件，当发生在 程序运行期间时，会干扰正常的指令流程。

在Java中，通过Throwable及其子类描述各种不同的异常类型。

Error

  • Error是程序无法处理的错误，表示运行应用程序中较严重问题。大多 数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。
  • 例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不 再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError
  • 这些错误是不可查的，因为它们在应用程序的控制和处理能力之外， 而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应 该试图去处理它所引起的异常状况。因此我们编写程序时不需要关心这类异常。

Exception

  • Exception是程序本身可以处理的异常。异常处理通常指针对这种类型 异常的处理。
  • Exception类的异常包括 checked exception 和 unchecked exception。
  • unchecked exception
    • unchecked exception：编译器不要求强制处置的异常。
    • 包含RuntimeException类及其子类异常。
    • 如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常)等，这些异常是 unchecked exception 。
    • Java编译器不会检查这些异常，在程序中可以选择捕获处理，也可以 不处理，照样正常编译通过。
  • checked exception
    • checked exception：编译器要求必须处置的异常。
    • 是RuntimeException及其子类以外，其他的Exception类的子类。
    • 如IOException、SQLException等
    • Java编译器会检查这些异常，当程序中可能出现这类异常时，要求必 须进行异常处理，否则编译不会通过。

二、异常处理

在Java应用程序中，异常处理机制为：抛出异常、捕捉异常

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

2、捕获异常 – 在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器。 – 运行时系统从发生异常的方法开始，依次回查调用栈中的方法，当异 常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合 适的异常处理器。 – 当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统 终止。同时，意味着Java程序的终止。 – 对于运行时异常、错误或可查异常，Java技术所要求的异常处理方式 有所不同。总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许 忽略不可查的RuntimeException和Error。 – 简单地说，异常总是先被抛出，后被捕捉的。

异常处理通过5个关键字来实现：try、catch、 finally、throw、throws

No.1 try-catch-finally try块后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。

catch、finally可选 语法组合：

  • try-catch
  • try-finally
  • try-catch-finally
  • try-catch-catch-finally

在try-catch块后加入finally块

  • 是否发生异常都执行
  • 不执行的唯一情况如下 
public void method() {          try {              // 代码段 1              // 产生异常的代码段 2          } catch (异常类型 ex) {              // 对异常进行处理的代码段3          } finally {              // 代码段 4          }      }    //Demo    package com.geekmubai;    import java.util.InputMismatchException;  import java.util.Scanner;    public class Error {        public static void main(String[] args) {          // 要求：定义两个整数，接受用户的键盘输入，输出两数之商          Scanner input=new Scanner(System.in);          System.out.println("=====运算开始=====");          try{              System.out.print("请输入第一个整数：");              int one=input.nextInt();              System.out.print("请输入第二个整数：");              int two=input.nextInt();              System.out.println("one和two的商是："+ (one/two));          }catch(ArithmeticException e){              System.exit(1);//终止程序运行              System.out.println("除数不允许为零");              e.printStackTrace();          }catch(InputMismatchException e){              System.out.println("请输入整数");              e.printStackTrace();          }catch(Exception e){              System.out.println("出错啦~~");              e.printStackTrace();          }finally{              System.out.println("=====运算结束=====");          }      }  }

No.2try-catch 使用try-catch块捕获并处理异常

public void method() {          try {              // 代码段          } catch (异常类型 ex) {              // 对异常进行处理的代码段          }              // 代码段      }

异常种类：

No.3 多重catch块 一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理 结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配 和捕获异常类型的机会。

对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的 catch子 句放在前面，同时尽量将捕获相对高层的异常类的catch子句放 在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽。

引发多种类型的异常

  • 排列catch 语句的顺序：先子类后父类
  • 发生异常时按顺序逐个匹配
  • 只执行第一个与异常类型匹配的catch语句

No.4 异常类型

|异 常 类 型|说 明| |—-|—-| Exception|异常层次结构的父类 |ArithmeticException|算术错误情形，如以零作除数 |ArrayIndexOutOfBoundsException|数组下标越界 |NullPointerException|尝试访问 null 对象成员 |ClassNotFoundException|不能加载所需的类 |IllegalArgumentException|方法接收到非法参数 |ClassCastException|对象强制类型转换出错 |NumberFormatException|数字格式转换异常，如把"abc" 转换成数字

No.5 总结

实际应用中的经验与总结

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

三、声明异常

可以通过throws声明将要抛出何种类型的异常，通过throw将产生的 异常抛出。

throw

  • 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法 声明处用throws子句来声明抛出异常。
  • 例如：汽车在运行时可能会出现故障，汽车本身没办法处理这个故障， 那就让开车的人来处理。

throws – throws语句用在方法定义时声明该方法要抛出的异常类型。

public void method() throws Exception1,Exception2,…,ExceptionN { // 可能产生异常的代码 }

1234

public void method() throws Exception1,Exception2,…,ExceptionN {// 可能产生异常的代码}
  • 当方法抛出异常列表中的异常时，方法将不对这些类型及其子类类型的 异常作处理，而抛向调用该方法的方法，由他去处理。

两种抛出异常的方法

//1、throws抛出大类异常，catch分小类  package com.geekmubai;    import java.util.InputMismatchException;  import java.util.Scanner;    public class throw1 {      public static void main(String[] args) {          try {              int result = test();              System.out.println("one和two的商是：" + result);          } catch (ArithmeticException e) {          } catch (InputMismatchException e) {          } catch (Exception e) {          }          int result2 = test();      }        /**       * 测试接收数据相除结果的方法       * @return 两个接收数据的商       * @throws ArithmeticException       * @throws InputMismatchException       */        public static int test() throws Exception {          Scanner input = new Scanner(System.in);          System.out.println("=====运算开始=====");          System.out.print("请输入第一个整数：");          int one = input.nextInt();          System.out.print("请输入第二个整数：");          int two = input.nextInt();          System.out.println("=====运算结束=====");          return one / two;      }  }      //2、throws抛出小类异常，catch分小类  package com.geekmubai;    import java.util.InputMismatchException;  import java.util.Scanner;    public class throwdemo {      public static void main(String[] args) {          try {              int result = test();              System.out.println("one和two的商是：" + result);          } catch (ArithmeticException e) {              System.out.println("除数不允许为零");              e.printStackTrace();          } catch (InputMismatchException e) {              System.out.println("请输入整数");              e.printStackTrace();          }      }  //    通过throws抛出异常时，针对可能出现的多种异常情况，解决方案：  //    throws后面接多个异常类型，中间用逗号分隔      public static int test() throws ArithmeticException, InputMismatchException {          Scanner input = new Scanner(System.in);          System.out.println("=====运算开始=====");          System.out.print("请输入第一个整数：");          int one = input.nextInt();          System.out.print("请输入第二个整数：");          int two = input.nextInt();          System.out.println("=====运算结束=====");          return one / two;      }  }

throws的使用规则 1、如果是不可查异常（unchecked exception），即Error、 RuntimeException或它们的子类，那么可以不使用throws关键字来 声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

2、如果一个方法中可能出现可查异常，要么用try-catch语句捕获， 要么用throws子句声明将它抛出，否则会导致编译错误

3、当抛出了异常，则该方法的调用者必须处理或者重新抛出该异常。

4、当子类重写父类抛出异常的方法时，声明的异常必须是父类方法所 声明异常的同类或子类。

throw抛出异常对象的处理方案： 通过try..catch包含throw语句——自己抛自己处理

try {              System.out.println("请输入年龄：");              Scanner input = new Scanner(System.in);              int age = input.nextInt();              if (age < 18 || age > 80) {                  throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");              } else {                  System.out.println("欢迎入住本酒店");              }          } catch (Exception e) {              e.printStackTrace();          }      }

通过throws在方法声明出抛出异常类型–谁调用谁处理–调用者可以自己处理，也可以继续上抛。此时可以抛出与throw对象相同的类型或者其父类。

package com.geekmubai;    import java.util.Scanner;    public class throw2 {      public static void main(String[] args) {          // TODO Auto-generated method stub          try {              testAge();          } catch (HotelAgeException e) {              System.out.println(e.getMessage());              System.out.println("酒店前台工作人员不允许办理入住登记");          }catch(Exception e){              e.printStackTrace();          }      }        public static void testAge() throws HotelAgeException {          System.out.println("请输入年龄：");          Scanner input = new Scanner(System.in);          int age = input.nextInt();          if (age < 18 || age > 80) {              //throw new ArithmeticException();              //throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");              throw new HotelAgeException();          } else {              System.out.println("欢迎入住本酒店");          }      }  }

四、自定义异常和异常链

自定义异常

  • 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。
  • 也可以通过自定义异常描述特定业务产生的异常类型。
  • 所谓自定义异常，就是定义一个类，去继承Throwable类或者它的子类。

异常链

  • 有时候我们会捕获一个异常后再抛出另一个异常
  • 顾名思义就是：将异常发生的原因一个传一个串起来，即把底层 的异常信息传给上层，这样逐层抛出
package com.imooc.test;    public class TryDemoFive {        public static void main(String[] args) {          // TODO Auto-generated method stub          try {              testThree();          } catch (Exception e) {              // TODO Auto-generated catch block              e.printStackTrace();          }      }        public static void testOne() throws HotelAgeException {          throw new HotelAgeException();      }        public static void testTwo() throws Exception {          try {              testOne();          } catch (HotelAgeException e) {              throw new Exception("我是新产生的异常1",e);          }      }        public static void testThree() throws Exception {          try {              testTwo();          } catch (Exception e) {              Exception e1=new Exception("我是新产生的异常2");              e1.initCause(e);              throw e1;  //          throw new Exception("我是新产生的异常2",e);          }      }  }

VirMach 便宜 VPS

QNews

QNews