java异常处理，零基础入门到精通，收藏这篇就够了-编程阁

一. 异常概述、体系

什么是异常？

为什么要学习异常？

如何处理异常？

假设我们有一个接收String参数的方法，方法中会对该参数进行一些逻辑处理，正常的业务流程要求不允许null值出现，可如果调用者传递了一个null值进来，此时我们该怎么做呢？

二. 常见运行时异常

三. 常见编译时异常

java.util.concurrent.BrokenBarrierException {CyclicBarrier.await()}

java.util.concurrent.ExecutionException

NoSuchMethodException{反射}

四. 异常的默认处理流程

五. 编译时异常的处理机制

编辑

六.Throwable类常用方法有哪些？try-catch-finally如何使用？

String getMessage(): 返回异常发生时的简要描述

String toString(): 返回异常发生时的详细信息

void printStackTrace(): 在控制台上打印 Throwable 对象封装的异常信息

try-catch-finally 如何使用？

finally 中的代码一定会执行吗？

如何使用 try-with-resources 代替try-catch-finally？

throw和throws的区别：

七. 运行时异常的处理机制

七. 异常处理使代码更稳健的案例

八. 自定义异常

补充：

1. try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

2. try-catch-finally 中哪个部分可以省略？

3. 主线程可以捕获到子线程的异常吗？

4. final、finally、finalize 有什么区别？

一. 异常概述、体系

什么是异常？

异常是程序在“编译”或者“执行”的过程中可能出现的错误 / 问题，而不是语法问题导致的编译错误，语法错误不算在异常体系中，语法错误是自己的水平问题引起的。
比如：数组索引越界异常、空指针异常、日期格式化异常，等…

为什么要学习异常？

异常一旦出现了，如果没有提前处理，程序就会退出JVM虚拟机而终止。
学习异常不是让我们以后不出异常，而是程序出了异常之后，该如何处理。体现的是程序的安全，健壮性。
Error：错误，Error是一种特殊的类(java.lang.Error)，与普通的Exception异常类不同，Error是程序无法处理的错误，Error类及其子类是指我们程序处理不了或者说不该由程序处理的错误，这类错误往往代表JVM在运行过程中出了问题，Error不应该由应用程序捕获和处理，而是由虚拟机自己处理，通常代表着虚拟机和系统级别的问题。
一些常见的Error比如：

Virtual MachineError：Java 虚拟机运行错误 =>内存溢出(OutOfMemoryError — 堆内存溢出，StackOverflowError — 栈内存溢出)
**java.lang.NoClassDefFoundError:**当虚拟机无法找到(找不到)要加载的类时抛出的错误。
**LinkageError：**当类加载过程出现链接错误时抛出的错误。

Java 异常类层次结构图

异常继承关系图

Java中的所有异常都来⾃顶级⽗类Throwable，Throwable下有两个⼦类Exception和Error。
Throwable类，是所有异常类的根类，Java异常的顶层父类，所有的异常类都是由它继承。
Exception：异常，程序本身可以处理的异常。
Java中异常继承的根类是：Throwable。Throwable是根类，不是异常类。
Exception才是异常类，当程序出现Exception时，是可以靠程序⾃⼰来解决的，它才是开发中代码在编译或者执行的过程中可能出现的错误，它是需要提前处理的，以便程序更健壮！
异常体系的最上层父类是Exception。
Exception的⼦类通常⼜可以分为RuntimeException和⾮RuntimeException两类
异常分为两类：编译时异常(受检异常，必须处理)、运行时异常(非受检异常)。
受检异常：就是程序必须手动处理的异常，如果不手动处理，则会编译失败。
非受检异常：不强制程序处理的异常，不强制你手动处理，无需try…catch…，也无需throws，代码也能编译成功。
Error也属于非受检异常。
编译时异常{受检异常-Checked Exception}：没有继承RuntimeException的异常，直接继承于Exception。编译阶段就会错误提示 / 报错，**必须要手动处理(如果受检查异常没有被catch或者throws关键字处理的话，就没办法通过编译)，否则代码报错不通过。编译时异常是为了提醒程序员，**比如：IOException、ClassNotFoundException、ParseException、SQLException、java.io.FileNotFoundException…
运行时异常{非受检异常-Unchecked Exception}：继承了RuntimeException，RuntimeException本身和子类。编译阶段不会报错 / 出现异常提醒，运行时出现的异常。运行时异常是代码出错而导致程序出现的问题。

package com.gch.d3_exception; /** 目标：异常的概念和体系。 */ public class ExceptionDemo { public static void main(String[] args) { int[] arr = {10, 20, 40}; System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr[3]); // ArrayIndexOutOfBoundsException System.out.println("-----------程序截止---------"); } }

package com.gch.d3_exception; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class ExceptionDemo1 { public static void main(String[] args) throws ParseException { // 编译时异常(在编译阶段,必须要手动处理,否则代码报错) String time = "2030年1月1日"; SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日"); Date date = sdf.parse(time); System.out.println(date); // Tue Jan 01 00:00:00 CST 2030 // 运行时报错(在编译阶段是不需要处理的,是代码运行时出现的异常) int[] arr = {1, 2, 3, 4, 5}; System.out.println(arr[10]); // ArrayIndexOutOfBoundsException } }

如何处理异常？

在Java中有两个处理异常的方式，一个是try…catch…，一个是throws。

try…catch：

try…catch{捕获异常}：将可能发生异常的代码放到try代码块中，然后使用catch来捕获对应的异常。
如果try代码块正常执行，那catch就不会生效；如果发生了指定的异常，则会执行对应的catch代码块，然后继续往下执行，如此一来，我们就能避免异常影响到我们的正常逻辑。
捕获异常时还可以接上finally代码块，无论有没有发生异常，finally代码块都会执行。

try代码块不能单独使用，应当搭配catch或finally代码块

package com.gch.exceptiondemo; import java.io.IOException; /** try捕获异常,catch处理异常 */ public class ExceptionDemo { public static void main(String[] args) throws Exception { // 可以catch一个也可以catch多个异常 try{ // 可能会发生异常的逻辑 throw new Exception(); }catch(IOException e){ // 发生IOException时,执行此代码块 System.out.println(e); }catch(ClassNotFoundException e){ // 发生ClassNotFoundException,执行此代码块 System.out.println(e); }catch(Exception e){ // 发生其它异常时,执行此代码块 // 父类异常应放在子类异常后面,否则子类不会被捕获 }finally{ // 无论是否发生异常,都会执行 // 如果没有加catch处理异常,finally虽会执行,但异常还是会影响正常逻辑 } } }

throws{抛出异常}：在方法上使用throws关键字可以声明该方法可能会抛出的异常。

当我们调用一个方法时，如果这个方法用throws关键字声明了受检异常，此时我们就必须得手动处理它声明的异常，否则就会编译失败{要么你就try…catch…，要么你就在当前方法使用throws声明同样的或其父类异常}。

package com.gch.exceptiondemo; import java.io.IOException; /** try捕获异常,catch处理异常 */ public class ExceptionDemo { public static void main(String[] args) throws Exception { // 可以catch一个也可以catch多个异常 try{ // 可能会发生异常的逻辑 throw new Exception(); }catch(IOException e){ // 发生IOException时,执行此代码块 System.out.println(e); }catch(ClassNotFoundException e){ // 发生ClassNotFoundException,执行此代码块 System.out.println(e); }catch(Exception e){ // 发生其它异常时,执行此代码块 // 父类异常应放在子类异常后面,否则子类不会被捕获 }finally{ // 无论是否发生异常,都会执行 // 如果没有加catch处理异常,finally虽会执行,但异常还是会影响正常逻辑 } } /** 可以throws声明一个或多个异常 */ /** * 可以throws声明一个或多个异常 * @throws IOException * @throws ClassNotFoundException */ public static void process() throws IOException,ClassNotFoundException{ // 可能会发生异常的逻辑 } public static void f1() { // 编译失败,编译器直接报错,因为没有手动处理受检异常{try...catch... / throws} process(); } public static void f2() { // 编译成功,因为try...catch处理异常了 // try { // process(); // } catch (IOException e) { // throw new RuntimeException(e); // } catch (ClassNotFoundException e) { // throw new RuntimeException(e); // } try{ process(); }catch(IOException | ClassNotFoundException e){ // ... } } public static void f3() throws IOException, ClassNotFoundException { // 编译成功,因为throws往外抛异常了 process(); } public static void f4(){ // 因为方法f2()已经try...catch...处理异常了,所以不用再手动处理了 f2(); } }

这里其实就可以体现出throws的作用了：那就是我不想处理这个异常时，我可以把这个问题往外抛，谁调用我谁就来处理，就好像在工作中出现了一个问题，你可以选择将这个问题自行解决，也可以选择将这个问题丢给你的上级解决，那你的上级碰到问题时，也会面临同样的选择，要么他自己解决，那么他就将问题抛给更上级。
如果一个问题或者说一个异常发生了后就一直往上抛，到最顶层的main方法了，都没人去try…catch…解决，那程序就会终止运行。

什么时候该try…catch…，什么时候该throws呢？

有一个很简单的原则就是：当前方法需要继续运行下去，就肯定得用try…catch…；当前方法不需要继续运行，就可以选择throws。
建议尽量选择捕获异常。

假设我们有一个接收String参数的方法，方法中会对该参数进行一些逻辑处理，正常的业务流程要求不允许null值出现，可如果调用者传递了一个null值进来，此时我们该怎么做呢？

第一种做法就是给参数设置一个默认值，然后继续执行后续逻辑：

/** * @param arg 参数不允许为null */ public static void method(String arg){ if(arg == null){ arg = "默认值"; } // 继续执行业务逻辑... }

第二种做法就是直接结束方法，不执行后面逻辑。{这里还可以返回不同的值，来表达方法执行的结果}

/** * @param arg 参数不能为null * @return 参数如果为null则返回false,否则为true */ public static boolean method(String arg) { if(arg == null){ return false; } // 业务逻辑... return true; }

第三种做法就是抛出异常

/** * @param arg 参数不能为null */ public static void method3(String arg) { if(arg == null){ throw new RuntimeException(); } // 业务逻辑... }

总结：如果碰到了会影响正常逻辑的情况，基本就这三大类处理方式 =>

二. 常见运行时异常

运行时异常的概念:继承自RuntimeException的异常或者其子类，
编译阶段是不会出错的，它是在运行时阶段可能出现的错误，
运行时异常编译阶段可以处理也可以不处理,代码编译都能通过！！

数组索引越界异常: ArrayIndexOutOfBoundsException。
空指针异常 : NullPointerException。直接输出没有问题。但是调用空指针的变量的功能就会报错！！
类型转换异常：ClassCastException。
迭代器遍历没有此元素异常：NoSuchElementException。
算术异常：ArithmeticException。
数字转换异常：NumberFormatException(字符串转换为数字格式错误，IllegalArgumentException的子类)。
非法线程状态异常：llegalThreadStateException
并发修改异常：java.util.ConcurrentModificationException(多线程下集合操作元素)
IllegalArgumentException：参数错误(比如方法入参类型错误)
SecurityException：安全错误(比如权限不够)
UnsupportedOperationException：不支持的操作错误(比如重复创建同一用户)
ArrayStoreException：数据存储异常（操作数组时类型不一致）
java.lang.IllegalStateException{Queue full依然add()添加元素}
FileSizeLimitExceededException：在SpringBoot中，文件上传时默认单个文件最大大小为1M，当上传一个较大的文件(超出1M)时，运行和后端程序报错
NoSuchBeanDefinitionException：表示在应用程序中没有找到指定的Bean的定义！在Spring容器ApplicationContext中调用getBean()获取bean对象时，bean的名称填错，就会报改错，或者就跟着没有该Bean对象！
UnsupportedClassVersionError：比如在JDK8上面运行JDK11环境下的程序！
java.lang.UnsupportedOperationException异常：使用Collections.unmodifiableCollection（Collection c）方法来创建一个只读集合，这样改变集合的任何操作都会抛出该异常~！

package com.gch.d4_exception_runtimeException; /** 拓展: 常见的运行时异常。（面试题） 运行时异常的概念: 继承自RuntimeException的异常或者其子类， 编译阶段是不会出错的，它是在运行时阶段可能出现的错误， 运行时异常编译阶段可以处理也可以不处理,代码编译都能通过！！ 1.数组索引越界异常: ArrayIndexOutOfBoundsException。 2.空指针异常 : NullPointerException。 直接输出没有问题。但是调用空指针的变量的功能就会报错！！ 3.类型转换异常：ClassCastException。 4.迭代器遍历没有此元素异常：NoSuchElementException。 5.算术异常：ArithmeticException。 6.数字转换异常：NumberFormatException。 小结： 运行时异常继承了RuntimeException ,编译阶段不报错，运行时才可能会出现错误! */ public class ExceptionDemo { public static void main(String[] args) { System.out.println("程序开始。。。。。。"); /** 1.数组索引越界异常: ArrayIndexOutOfBoundsException。*/ int[] arr = {1, 2, 3}; System.out.println(arr[2]); // System.out.println(arr[3]); // 运行出错，程序终止 /** 2.空指针异常 : NullPointerException。直接输出没有问题。但是调用空指针的变量的功能就会报错！！ */ String name = null; System.out.println(name); // null // System.out.println(name.length()); // 运行出错，程序终止 /** 3.类型转换异常：ClassCastException。 */ Object o = 23; // String s = (String) o; // 运行出错，程序终止 /** 5.数学操作 / 算术异常：ArithmeticException。 */ //int c = 10 / 0; /** 6.数字转换异常： NumberFormatException。 */ //String number = "23"; String number = "23aabbc"; Integer it = Integer.valueOf(number); // 运行出错，程序终止 System.out.println(it + 1); System.out.println("程序结束。。。。。"); } }

三. 常见编译时异常

当调用一个抛出异常的方法的时候，调用者必须处理这个异常(try…catch…或者throws)，如果不处理，编译失败！

IOException
ClassNotFoundException
ParseException
SQLException
FileNotFoundException
java.lang.InterruptedException
CloneNotSupportedException、
java.util.concurrent.ExecutionException
java.util.concurrent.TimeoutException
**java.util.concurrent.**BrokenBarrierException {CyclicBarrier.await()}
java.util.concurrent.ExecutionException
NoSuchMethodException{反射}
ServletException

package com.gch.d5_exception_javac; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /** 目标：常见的编译时异常认识。 编译时异常：继承自Exception的异常或者其子类，没有继承RuntimeException "编译时异常是编译阶段就会报错"， 必须程序员编译阶段就处理的。否则代码编译就报错！！ 编译时异常的作用是什么： 是担心程序员的技术不行，在编译阶段就爆出一个错误, 目的在于提醒! 提醒程序员这里很可能出错，请检查并注意不要出bug。 编译时异常是可遇不可求。遇到了就遇到了呗。 了解: */ public class ExceptionDemo { // 解析异常 public static void main(String[] args) throws ParseException { String date = "2015-01-12 10:23:21"; // 创建一个简单日期格式化类： SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 解析字符串时间成为日期对象 Date d = sdf.parse(date); System.out.println(d); // Mon Jan 12 10:23:21 CST 2015 } }

四. 异常的默认处理流程

五. 编译时异常的处理机制

六.Throwable类常用方法有哪些？try-catch-finally如何使用？

Throwable类常用方法：

String getMessage(): 返回异常发生时的简要描述
String toString(): 返回异常发生时的详细信息
void printStackTrace(): 在控制台上打印Throwable对象封装的异常信息

public synchronized Throwable **getCause()：获取实际的异常原因**

try-catch-finally 如何使用？

try块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch块：用于处理 try 捕获到的异常。
finally块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。可以在finally代码块中进行资源的释放！

注意：不要在 finally 语句块中使用 return!

当 try 语句和 finally 语句中都有 return 语句时，try 语句块中的 return 语句会被忽略。
这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中，当执行到 finally 语句中的 return 之后，这个本地变量的值就变为了 finally 语句中的 return 返回值。

jvm 官方文档open in new windowhttps://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.10.2.5JVM官方文档中有明确提到：

代码示例：

public static void main(String[] args) { System.out.println(f(2)); } public static int f(int value) { try { return value * value; } finally { if (value == 2) { return 0; } } }

finally 中的代码一定会执行吗？

**不一定的！**在某些情况下，finally 中的代码不会被执行。
就比如说 finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。

try { System.out.println("Try to do something"); throw new RuntimeException("RuntimeException"); } catch (Exception e) { System.out.println("Catch Exception -> " + e.getMessage()); // 终止当前正在运行的Java虚拟机 System.exit(1); } finally { System.out.println("Finally"); }

另外，在以下几种特殊情况下，finally块的代码也不会被执行：

如何使用`try-with-resources`代替`try-catch-finally`？

适用范围（资源的定义）：任何实现java.lang.AutoCloseable或者java.io.Closeable接口的类对象才能定义为资源。
关闭资源：try(定义资源{流}对象：资源1；资源2)=>用完会自动调用资源对象的close方法关闭资源，即使出现异常也会做关闭操作，无需再在finally代码块中手动调用资源的close方法进行资源的关闭。

throw和throws的区别：

thow

用在方法体内，跟的是异常对象名 => new
只能抛出一个异常对象名
throw是用来主动制造并抛出异常，由方法体内的语句处理
throw是抛出了异常，执行throw则一定抛出了某种异常
关键字 throw 后面，写异常类的对象=>new

throws

throws关键字用/写在方法的声明上，不是方法内部
throws后面跟的是异常类名，不是对象 => new
throws是声明方法可能会发生的异常，throws表示抛出异常，由该方法的调用者来处理，处理方式：调用者可以throws继续向上抛出或者在方法内部使用try…catch…
throws表示出现异常的一种可能性，并不一定会发生这些异常

注意：如果main方法里面单独开启了一条线程，并且调用了抛出异常的方法，则只能在方法内部进行try…catch处理，因为方法内部不能使用throws抛出异常类！

七. 运行时异常的处理机制

七. 异常处理使代码更稳健的案例

package com.gch.d8_handle_runtime; import java.sql.SQLOutput; import java.util.Scanner; /** 需求:需要输入一个合法的价格为止 要求价格大于0 */ public class Test2 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); while(true){ try { System.out.println("请您输入价格:"); String priceStr = sc.nextLine(); // 转换成Double类型的价格 double price = Double.valueOf(priceStr); // 判断价格是否大于0 if(price > 0){ System.out.println("定价:" + price); break; }else{ System.out.println("价格必须是正数~~~"); } } catch (NumberFormatException e) { System.out.println("程序有误!"); // throw new RuntimeException(e); } } } }