Java异常详解(全文干货)

介绍

Throwable

Throwable 是 Java 语言中全部错误与异常的超类。
Throwable 包含两个子类：Error（错误）和 Exception（异常），它们通常用于指示发生了异常环境。
Throwable 包含了其线程创建时线程执行堆栈的快照，它提供了 printStackTrace() 等接口用于获取堆栈跟踪数据等信息。
Error（错误）

Error 类及其子类：步伐中无法处理的错误，体现运行应用步伐中出现了严重的错误。
此类错误一般体现代码运行时 JVM 出现问题。通常有

• Virtual MachineError（虚拟机运行错误）
  
• NoClassDefFoundError（类定义错误）
  
• OutOfMemoryError：内存不足错误
  
• StackOverflowError：栈溢堕落误。
  

此类错误发生时，JVM 将终止线程。这些错误是不受检异常，非代码性错误。因此，当此类错误发生时，应用步伐不应该去处理此类错误。按照Java惯例，我们是不应该实现任何新的Error子类的！
Exception（异常）

步伐本身可以捕获并且可以处理的异常。Exception 这种异常又分为两类：运行时异常和编译时异常。

• 运行时异常（unchecked exceptions）
  
  
  
  • 都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，步伐中可以选择捕获处理，也可以不处理。这些异常一般是由步伐逻辑错误引起的，步伐应该从逻辑角度尽大概避免这类异常的发生。
    
  • 运行时异常的特点是Java编译器不会检查它，也就是说，当步伐中大概出现这类异常，纵然没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
    
  
  
• 非运行时异常（checked exceptions，编译时异常）
  
  
  
  • 是RuntimeException以外的异常，范例上都属于Exception类及其子类。从步伐语法角度讲是必须进行处理的异常，假如不处理，步伐就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般环境下不自定义检查异常。
    
  
  

常见的异常

在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要步伐员进行捕获处理或声明抛出，有的是由Java虚拟机主动进行捕获处理。Java中常见的异常类:

• RuntimeException
  
  
  
  • java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组巨细时抛出。
    
  • java.lang.ArithmeticException 算术条件异常。譬如：整数除零等。
    
  • java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、盘算null对象的长度、使用throw语句抛出null等等
    
  • java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
    
  • java.lang.NegativeArraySizeException 数组长度为负异常
    
  • java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
    
  • java.lang.SecurityException 安全性异常
    
  • java.lang.IllegalArgumentException 非法参数异常
    
  
  
• IOException
  
  
  
  • IOException：利用输入流和输出流时大概出现的异常。
    
  • EOFException 文件已结束异常
    
  • FileNotFoundException 文件未找到异常
    
  
  
• 其他
  
  
  
  • ClassCastException 范例转换异常类
    
  • ArrayStoreException 数组中包含不兼容的值抛出的异常
    
  • SQLException 利用数据库异常类
    
  • NoSuchFieldException 字段未找到异常
    
  • NoSuchMethodException 方法未找到抛出的异常
    
  • NumberFormatException 字符串转换为数字抛出的异常
    
  • StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
    
  • IllegalAccessException 不答应访问某类异常
    
  • InstantiationException 当应用步伐试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
    
  
  

这些异常时Java内置的异常类，当然用户也可以根据业务自定义自己的异常类：

1. public class MyException extends RuntimeException {
2.     // 无参构造器
3.     public MyException() {}
5.     // 带有详细信息的构造器
6.     public MyException(String message) {
7.         super(message);
8.     }
10.     // 带有引起此异常的原因的构造器
11.     public MyException(Throwable cause) {
12.         super(cause);
13.     }
15.     // 同时包含错误信息和原因的构造器
16.     public MyException(String message, Throwable cause) {
17.         super(message, cause);
18.     }
19. }

复制代码

异常的处理方式

• try-catch：希望出现异常后步伐继续运行，则在选中语句后，采用：
  
• throw：在出现异常的条件下的方法体内直接throw出异常：执行throw则一定抛出了异常。可以明白为，在编程之前就预想到大概发生的异常，那么：
  

1. if（预想的异常情况出现）{   
2.     throw new 相应的异常()；//可以是自定义的异常
3. } //还可以在括号内写上出现异常时的”输出语句“

复制代码

即：既要发现异常，又要处理异常。
别的：这种具有针对性的声明只能抛出单个异常

• throws：与throw方法不同，throws跟在方法声明后面，扔出使用此方法大概发生（或者在定义大概出现异常的变量的当前类后面throws出异常）的异常。其只是发现异常，而不处理，交给方法的调用者来处理。并且一次可以抛出多个异常。
  

异常常用方法

• getMessage()：返回关于发生的异常的详细信息，如有必要，还需要带上抛出异常时一些状态变量。
  
• printStackTrace()：在标准错误流中输出异常堆栈。这个方法对于打印详细的错误信息非常有用，因为它体现了异常从发生到被捕获的代码执行路径，但是这个方法无论何时都不应该被调用。
  
• toString()：返回一个简短的描述，包括：Throwable的非完全限定类名，然后是getMessage()的结果。
  
• getCause()：返回造成此Throwable的原因，或者返回null假如原因不存在或者未知。
  
• getStackTrace()：返回一个体现该Throwable堆栈跟踪的StackTraceElement数组。
  

try-catch-finally

执行次序

• 当try没有捕获到异常时：try语句块中的语句逐一被执行，步伐将跳过catch语句块，执行finally语句块和其后的语句；
  
• 当try捕获到异常，catch语句块里没有处理此异常的环境：
  
  
  
  • 当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；
    
  • 当try捕获到异常，catch语句块里有处理此异常的环境：在try语句块中是按照次序来执行的，当执行到某一条语句出现异常时，步伐将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理步伐，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；
    
  
  

执行流程图如下：

也可以直接用try-finally，不使用catch，可用在不需要捕获异常的代码，可以保证资源在使用后被关闭。例如IO流中执行完相应利用后，关闭相应资源；使用Lock对象保证线程同步，通过finally可以保证锁会被释放；数据库连接代码时，关闭连接利用等等。
finally遇见如下环境不会执行：

• 在前面的代码中用了System.exit()退出步伐。
  
• finally语句块中发生了异常。
  
• 步伐所在的线程死亡。
  
• 关闭CPU。
  

finally 经典异常处理代码题

题目一

1. public class Test {
2.     public static void main(String[] args) {
3.         System.out.println(test());
4.     }
5.     public static int test() {
6.         try {
7.             return 1;
8.         } catch (Exception e) {
9.             return 2;
10.         } finally {
11.             System.out.print("3");
12.         }
13.     }
14. }
15. //输出：
16. 31

复制代码

try、catch、finally 的基础用法，在 return 前会先执行 finally 语句块，所以会先输出 finally 里的 3，再输出 return 的 1。由于这里try中没有异常发生，因此catch中的return不会执行
题目二

1. public class Test {
2.     public static void main(String[] args) {
3.         System.out.println(test());
4.     }
5.     public static int test() {
6.         try {
7.             int i = 1/0;
8.             return 1;
9.         } catch (Exception e) {
10.             return 2;
11.         } finally {
12.             System.out.print("3");
13.         }
14.     }
15. }
16. //输出：
17. 32

复制代码

在 return 前会先执行 finally 语句块，所以会先输出 finally 里的 3，再输出 catch 中 return 的 2。由于这里try中有异常发生，因此try后续语句不会再执行
题目三

1. public class Test {
2.     public static void main(String[] args) {
3.         System.out.println(test());
4.     }
5.     public static int test() {
6.         try {
7.             return 2;
8.         } finally {
9.             return 3;
10.         }
11.     }
12. }
13. //输出：
14. 3

复制代码

try中的return前先执行 finally，结果 finally 直接 return 了，自然也就走不到 try 里面的 return 了。
题目四

1. public class Test {
2.     public static void main(String[] args) {
3.         System.out.println(test());
4.     }
5.     public static int test() {
6.         int i = 0;
7.         try {
8.             i = 2;
9.             return i;
10.         } finally {
11.             i = 3;
12.         }
13.     }
14. }
15. //输出：
16. 2

复制代码

在执行 finally 之前，JVM 会先将 i 的结果暂存起来，然后 finally 执行完毕后，会返回之前暂存的结果，而不是返回 i，所以纵然 i 已经被修改为 3，最终返回的还是之前暂存起来的结果 2。
总结

• 无论try中是否有return，是否有异常，finally都一定会执行。
  
• 假如try中有异常发生，会执行catch中的句子，try中异常后续的位置的语句不会再被执行
  
• 当try与finally语句中均有return语句，会忽略try中return。
  
• try中有return, 会先将值暂存，无论finally语句中对该值做什么处理，最终返回的都是try语句中的暂存值。
  

try-with-resources语法糖

配景

每当有关闭资源的需求都会使用到try-finally这个语句，比如在使用锁的时候，无论是本地的可重入锁还是分布式锁都会有下面雷同的结构代码，会在finally里面进行unlock，用于强制解锁：

1. Lock lock = new ReentrantLock();
2. lock.lock();
3. try {
4.     // doSometing
5. } finally {
6.     lock.unlock();
7. }

复制代码

或者使用java的文件流读取或者写入文件的时候，也会在finally中强制关闭文件流，防止资源走漏。

1. InputStream inputStream = new FileInputStream("file");
2. try {
3.     System.out.println(inputStream.read(new byte[4]));
4. } finally {
5.     inputStream.close();
6. }

复制代码

其实乍一看 这样的写法应该没什么问题，但是假如出现了多个资源需要关闭我们应该怎么写呢？最常见的写法如下：

1. InputStream inputStream = new FileInputStream("file");
2. OutputStream outStream = new FileOutputStream("file1");
4. try {
5.     System.out.println(inputStream.read(new byte[4]));
6.     outStream.write(new byte[4]);
7. } finally {
8.     inputStream.close();
9.     outStream.close();
10. }

复制代码

在外面定义了两个资源，然后在finally里面依次对这两个资源进行关闭，那么这个那里有问题呢？
问题其实在于假如在inputStream.close的时候抛出异常，那么outStream.close()就不会执行，这很明显不是想要的结果，所以后面就改成了下面这种多重嵌套的方式去写：

1. InputStream inputStream = new FileInputStream("file");
2. try {
3.     System.out.println(inputStream.read(new byte[4]));
4.     try {
5.         OutputStream outStream = new FileOutputStream("file1");
6.         outStream.write(new byte[4]);
7.     } finally {
8.         outStream.close();
9.     }
10. } finally {
11.     inputStream.close();
12. }

复制代码

在这种方式中即便是outStream.close()抛出了异常，但是依然会执行到inputStream.close(),因为他们是在不同的finally块，这个简直办理了问题，但是还有两个问题没有办理：

• 假如有不止两个资源，比如有十个资源，难道要写十个嵌套的语句吗？写完之后这个代码还能看吗？
  
• 假如在try里面出现异常，然后在finally里面又出现异常，就会导致异常覆盖，会导致finally里面的异常将try的异常覆盖了。
  

1. public class CloseTest {
3.     public void close(){
4.         throw new RuntimeException("close");
5.     }
7.     public static void main(String[] args) {
8.         CloseTest closeTest = new CloseTest();
9.         try{
10.             throw new RuntimeException("doSomething");
11.         }finally {
12.             closeTest.close();
13.         }
14.     }
16. }
17. //输出结果：Exception in thread "main" java.lang.RuntimeException: close

复制代码

上面这个代码，期望的是能抛出doSomething的这个异常，但是实际的数据结果却是close的异常，这和预期不符合。
try-with-resources如何办理的

上面介绍了两个问题，于是在java7中引入了try-with-resources的语句，只要资源实现了AutoCloseable这个接口那就可以使用这个语句了,之前的文件流已经实现了这个接口，因此可以直接使用：

1. try (InputStream inputStream = new FileInputStream("file");
2.     OutputStream outStream = new FileOutputStream("file1")) {
3.     System.out.println(inputStream.read(new byte[4]));
4.     outStream.write(new byte[4]);
5. }

复制代码

全部的资源定义全部都在try后面的括号中进行定义，通过这种方式就可以办理上面所说的几个问题：

• 通过这样的方式，代码非常整洁，无论有多少个资源，都可以很简便的去做。
  
• 异常覆盖问题，可以通过实验来看一下，将代码改写为如下：
  

1. public class CloseTest implements AutoCloseable {
3.     @Override
4.     public void close(){
5.         System.out.println("close");
6.         throw new RuntimeException("close");
7.     }
9.     public static void main(String[] args) {
10.         try(CloseTest closeTest = new CloseTest();
11.             CloseTest closeTest1 = new CloseTest();){
12.             throw new RuntimeException("Something");
13.         }
14.     }
16. }
17. //输出结果为：
18. close
19. close
20. Exception in thread "main" java.lang.RuntimeException: Something
21.     at fudao.CloseTest.main(CloseTest.java:33)
22.     Suppressed: java.lang.RuntimeException: close
23.         at fudao.CloseTest.close(CloseTest.java:26)
24.         at fudao.CloseTest.main(CloseTest.java:34)
25.     Suppressed: java.lang.RuntimeException: close
26.         at fudao.CloseTest.close(CloseTest.java:26)
27.         at fudao.CloseTest.main(CloseTest.java:34)

复制代码

在代码中定义了两个CloseTest，用来验证之前close出现异常是否会影响第二个，同时在close和try块里面都抛出不同的异常，可以看见结果，输出了两个close，证明虽然close抛出异常，但是两个close都会执行。然后输出了doSomething的异常，可以发现这里输出的就是try块里面所抛出的异常，并且close的异常以Suppressed的方式记录在异常的堆栈里面，通过这样的方式两种异常都能记录下来。
异常实现原理

JVM处理异常的机制

Exception Table，称为异常表
try-catch

1. public static void simpleTryCatch() {
2.    try {
3.        testNPE();
4.    } catch (Exception e) {
5.        e.printStackTrace();
6.    }
7. }

复制代码

使用javap来分析这段代码

1. //javap -c Main
2. public static void simpleTryCatch();
3.     Code:
4.        0: invokestatic  #3                  // Method testNPE:()V
5.        3: goto          11
6.        6: astore_0
7.        7: aload_0
8.        8: invokevirtual #5                  // Method java/lang/Exception.printStackTrace:()V
9.       11: return
10.     Exception table:
11.        from    to  target type
12.            0     3     6   Class java/lang/Exception

复制代码

异常表中包含了一个或多个异常处理者(Exception Handler)的信息，这些信息包含如下

• from 大概发生异常的起始点
  
• to 大概发生异常的结束点
  
• target 上述from和to之前发生异常后的异常处理者的位置
  
• type 异常处理者处理的异常的类信息
  

当一个异常发生时，JVM处理异常的机制如下：

• JVM会在当前出现异常的方法中，查找异常表，是否有合适的处理者来处理
  
• 假如当前方法异常表不为空，并且异常符合处理者的from和to节点，并且type也匹配，则JVM调用位于target的调用者来处理。
  
• 假如上一条未找到合理的处理者，则继续查找异常表中的剩余条目
  
• 假如当前方法的异常表无法处理，则向上查找（弹栈处理）刚刚调用该方法的调用处，并重复上面的利用。
  
• 假如全部的栈帧被弹出，仍然没有处理，则抛给当前的Thread，Thread则会终止。
  
• 假如当前Thread为最后一个非守护线程，且未处理异常，则会导致JVM终止运行。
  

try-catch-finally

1. public static void simpleTryCatchFinally() {
2.    try {
3.        testNPE();
4.    } catch (Exception e) {
5.        e.printStackTrace();
6.    } finally {
7.        System.out.println("Finally");
8.    }
9. }

复制代码

同样使用javap分析一下代码

1. public static void simpleTryCatchFinally();
2.     Code:
3.       
4.       //try 部分:
5.       //如果有异常，则调用14位置代码，也就是catch部分代码
6.       //如果没有异常发生，则执行输出finally操作，直至goto到41位置，执行返回操作。   
8.        0: invokestatic  #3                  // Method testNPE:()V
9.        3: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
10.        6: ldc           #7                  // String Finally
11.        8: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
12.       11: goto          41
14.       //catch部分:。如果没有异常发生，则执行输出finally操作，直至执行got到41位置，执行返回操作。
15.       14: astore_0
16.       15: aload_0
17.       16: invokevirtual #5                  // Method java/lang/Exception.printStackTrace:()V
18.       19: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
19.       22: ldc           #7                  // String Finally
20.       24: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
21.       27: goto          41
22.       
23.       //finally部分的代码如果被调用，有可能是try部分，也有可能是catch部分发生异常。
24.       30: astore_1
25.       31: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
26.       34: ldc           #7                  // String Finally
27.       36: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
28.       39: aload_1
29.       40: athrow     //如果异常没有被catch捕获，而是到了这里，执行完finally的语句后，仍然要把这个异常抛出去，传递给调用处。
30.       41: return
31.     Exception table:
32.        from    to  target type
33.            0     3    14   Class java/lang/Exception
34.            0     3    30   any
35.           14    19    30   any

复制代码

上面的三条异常表item的意思为:

• 假如0到3之间，发生了Exception范例的异常，调用14位置的异常处理者。
  
• 假如0到3之间，无论发生什么异常，都调用30位置的处理者
  
• 假如14到19之间（即catch部门），岂论发生什么异常，都调用30位置的处理者。
  

其实后两点的意思就是，无论有没有异常，finally语句块一定会被调用
try-with-resources

try-with-resources语句其实是一种语法糖，通过编译之后又回到了开始说的嵌套的那种模式：

可以发现try-with-resources被编译之后，又接纳了嵌套的模式，但是和之前的嵌套有点不同，他close的时候都使用了catch去捕获了异常，然后添加到真正的异常中，整体逻辑比之前我们自己的嵌套要复杂一些。
异常耗时

下面的测试用例简单的测试了创建对象、创建异常对象、抛出并接住异常对象三者的耗时对比：

1. public class ExceptionTest {  
2.   
3.     private int testTimes;  
4.   
5.     public ExceptionTest(int testTimes) {  
6.         this.testTimes = testTimes;  
7.     }  
8.   
9.     public void newObject() {  
10.         long l = System.nanoTime();  
11.         for (int i = 0; i < testTimes; i++) {  
12.             new Object();  
13.         }  
14.         System.out.println("建立对象：" + (System.nanoTime() - l));  
15.     }  
16.   
17.     public void newException() {  
18.         long l = System.nanoTime();  
19.         for (int i = 0; i < testTimes; i++) {  
20.             new Exception();  
21.         }  
22.         System.out.println("建立异常对象：" + (System.nanoTime() - l));  
23.     }  
24.   
25.     public void catchException() {  
26.         long l = System.nanoTime();  
27.         for (int i = 0; i < testTimes; i++) {  
28.             try {  
29.                 throw new Exception();  
30.             } catch (Exception e) {  
31.             }  
32.         }  
33.         System.out.println("建立、抛出并接住异常对象：" + (System.nanoTime() - l));  
34.     }  
35.   
36.     public static void main(String[] args) {  
37.         ExceptionTest test = new ExceptionTest(10000);  
38.         test.newObject();  
39.         test.newException();  
40.         test.catchException();  
41.     }  
42. }  
44. //结果：
45. 建立对象：575817  
46. 建立异常对象：9589080  
47. 建立、抛出并接住异常对象：47394475

复制代码

创建一个异常对象，是创建一个平凡Object耗时的约20倍（实际上差距会比这个数字更大一些，因为循环也占用了时间，追求准确的读者可以再测一下空循环的耗时然后在对比前减掉这部门），而抛出、接住一个异常对象，所耗费时间大约是创建异常对象的4倍。
关于作者

来自一线步伐员Seven的探索与实践，持续学习迭代中~
本文已收录于我的个人博客：https://www.seven97.top
公众号：seven97，接待关注~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。