一 异常体系结构

在Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)。
Java异常体系的基类是：Throwable，是所有异常类的组类
Java程序在执行过程中发生的异常事件可分为两类，如下

1.1 Error错误

1）完整包名：java.lang.Error
2）Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

  • StackOverflowError
  • OOM

    1.2 Exception异常

    完整包名：java.lang.Exception 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。

1）空指针访问
2）读取不存在的文件
3）网络中断连接
4）数组角标越界

  • 蓝色：非受检(unchecked)异常；红色：受检(checked)异常

image.png

1.3 编译时异常

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

1.4 运行时异常

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

二 常见的异常类

1）NullPoinerException 2）ArithmeticException

2.1 NullPointerException

  1. // NullPointerException 空指针异常
  2. @Test
  3. public void test() {
  4.     String str = "abc";
  5.     str = null;
  6.     System.out.println(str.toCharArray());
  7. }

2.2 ArithmeticException

  1. // ArithmeticException 数值运算异常
  2. @Test
  3. public void test1() {
  4.     int a = 9;
  5.     int b = 0;
  6.     System.out.println(a / b);
  7.     //java.lang.ArithmeticException: / by zero
  8. }

2.3 InputMismatchException

  1. // InputMismatchException 输入不匹配异常
  2. @Test
  3. public void test2() {
  4.     Scanner scanner = new Scanner(System.in);
  5.     System.out.println("请输入数字：");
  6.     int a = scanner.nextInt();
  7.     System.out.println(a);
  8. }

2.4 ArrayIndexOutOfBoundsException

  1. // ArrayIndexOutOfBoundsException 数组下标越界异常
  2. @Test
  3. public void test3() {
  4.     int[] a = {1, 2, 3};
  5.     System.out.println(a[3]);
  6. }

2.5 StringIndexOutOfBoundsException

  1. // StringIndexOutOfBoundsException 字符串下标越界异常
  2. @Test
  3. public void test5() {
  4.     String string = "abcde";
  5.     System.out.println(string.charAt(5));
  6.     // java.lang.StringIndexOutOfBoundsException: String index out of range: 5
  7. }

2.6 ClassCastException

  1. // ClassCastException 类型转换异常
  2. @Test
  3. public void test4() {
  4.     Object obj = new String("abc");
  5.     Date date = (Date) obj;
  6.     // java.lang.ClassCastException: java.lang.String cannot be cast to java.util.Date
  7. }

2.7 NumberFormatException

  1. // NumberFormatException 数值格式化异常
  2. @Test
  3. public void test6() {
  4.     String str = "123";
  5.     str = "abc";
  6.     int a = Integer.valueOf(str);
  7.     System.out.println(a);
  8.     // java.lang.NumberFormatException: For input string: "abc"
  9. }

三 异常的处理方式

3.1 异常处理方式一：try-catch-finally

3.1.2 概述

1）将可能出现异常的代码，使用try进行包裹，执行过程中，一旦生成异常对象，就将此对象抛出，在其后的catch中进行类型的匹配。
2）一旦异常对象与相应的某个catch中的异常类型匹配，则进入catch结构执行异常处理的操作。一旦执行完异常处理的操作后，直接跳出当前的try-catch结构，并执行其后的代码。
3）如果多个catch中的异常类型有子父类关系，则必须将子类异常声明在父类异常之前。否则报错。
4）在try中声明的变量，在出了try结构以后，不可被调用。

3.1.2 异常对象的生成

1）由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。
2）由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。

3.1.3 异常的抛出机制

image.png
为保证程序正常执行，代码必须对可能出现的异常进行处理。

3.1.4 捕获异常

1）如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。
2）如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。
3）程序员通常只能处理Exception，而对Error无能为力。

3.1.5 处理异常的步骤

1）try语句
捕获异常的第一步是用 try{…} 语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中

2）catch中处理信息
①自定义输出语句
②打印异常的信息：System.out.println(e.getMessage())
③打印栈的追踪信息：e.printStackTrace()

3）finally语句
①finally语句是可以选择的。
②finally中的代码是一定会被运行。
③finally中如果有return语句的话，那么不管try，catch语句中是否有return，一定执行的是finally中的return语句。注意：虽然try-catch中的return返回的值不是最终返回的值，但是如果有顺序执行到的话依然是一样会被执行的。
④一般在finally中关闭资源： 关闭流资源，关闭socket资源，关闭数据连接资源。

3.2 异常处理方式二：throws+异常类型

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

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

3）注意：这种异常处理方式并没有真正的处理异常，只是将异常抛给了上一个调用此方法的方法，还需继续处理异常

3.3 手动抛出异常

Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。 这种方式是属于生成异常的过程，不属于处理异常的过程。

1）首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)。

  1. IOException e = new IOException();
  2. throw e;

2）可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误

  1. throw new RuntimeException("want to throw");

四 自定义异常类

1）一般地，用户自定义异常类都是 RuntimeException 的子类。
2）自定义异常类通常需要编写几个重载的构造器。
3）自定义异常需要提供 serialVersionUID
4）自定义的异常通过 throw 抛出。
5）自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

4.1 开发步骤

1）继承现有的异常体系
2）定义一个序列版本号ID常量：serialVersionUID
3）提供重载的构造器，一般提供两个，一个空参，一个带字符串参数

  1. public class HomeShopException extends Exception {
  2.     // 自定义一个常量 版本号id 数值随便写，作用是区分不同的版本ID
  3.     static final long serialVersionUID = -33229948L;
  4.     public HomeShopException() {
  5.         super();
  6.     }
  7.     public HomeShopException(String message) {
  8.         super(message);
  9.     }
  10. }

五 面试相关

1、说说你开发中常见的异常有哪些？
1）concurrentModifyException

2、区分 finalize、final、finally
final：最终的，可以修饰属性，方法，类。修饰属性是，表示当前为常量，如果值是基本类型，则不可改变，如果值是引用类型，那么值中保存的地址不能被改变，但是引用类型的对象中的属性或者方法是可以改变的。
finally：try-catch-finally语句中的可选结构，表示一定会执行的代码。
finalize()：是Object类中的一个方法，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用

3、方法重写时，子类抛出的异常为什么是父类异常的子类？
因为不能超过父类定义处理的异常

4、throws和throw的区别
throw 可以抛出自己定义的异常对象
throws 是捕获到了当前方法产生的异常，然后再抛到上层方法中

5、try-catch-finally 中哪个部分可以省略？
catch，finally 都可以直接省略，但是不能处理异常信息了

6、如果在try，catch，finally 中都定义了 return，那么执行顺序是什么？
1、如果只有 try 中有 return，那么执行顺序是：
try 语句 ——> finally 语句 ——> try 中的 return 语句

2、在 try 中使用 return，finally 中也使用了 return，那么执行顺序是：
try 语句 ——> finally 语句 ——> finally 中的 return（try 的 return 语句不会被执行）

3、在catch，finally 语句中使用 return，那么执行顺序是：
try 语句 ——> finally 语句 ——> finally 中的 return（catch 的 return 语句不会被执行）

总结：无论怎样，只要在 finally 中定义了 return 语句，那么则是一定会执行 finally 中的 return 语句！

7、注意catch语句中的异常类型匹配原则