一、异常概述
异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。
异常发生的原因有很多，通常包含以下几大类：
- 用户输入了非法数据。
- 要打开的文件不存在。
- 网络通信时连接中断，或者JVM内存溢出。
这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的，为增强程序的健壮性，计算机程序的编写也需要考虑处理这些异常情况，Java语言提供了异常处理功能，本文将介绍Java异常处理机制。
为了更好的理解和学习Java异常处理机制，首先看看下面程序：
//HelloWorld.java文件
package com.Kevin;
public class HelloWorld {
public static void main(String[] args) {
int a = 0;
System.out.println(5 / a);
}
}
这个程序没有编译错误，但会发生如下的运行时错误：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at com.Kevin.HelloWorld.main(HelloWorld.java:9)
在数学上除数不能为0，所以程序运行时表达式（5 / a）会抛出ArithmeticException异常，ArithmeticException是数学计算异常，凡是发生数学计算错误都会抛出该异常。
程序运行过程中难免会发生异常，发生异常并不可怕，程序员应该考虑到有可能发生这些异常，编程时应该捕获并进行处理异常，不能让程序发生终止，这就是健壮的程序。
二、异常类继承层次
所有的异常类是从 java.lang.Exception 类继承的子类。Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。Error 用来指示运行时环境发生的错误。例如，JVM 内存溢出。一般地，程序不会从错误中恢复。异常类有两个主要的子类：IOException 类和 RuntimeException 类。Java的异常类继承层次具体如下图：
Java异常类继承层次图
2.1 Throwable类
从Java异常类继承层次图可见，所有的异常类都直接或间接地继承于java.lang.Throwable类，在Throwable类有几个非常重要的方法：
- String getMessage()：获得发生异常的详细消息。
- void printStackTrace()：打印异常堆栈跟踪信息。
- String toString()：获得异常对象的描述。
为了介绍Throwable类的使用，示例代码如下：
1 //HelloWorld.java文件
2 package com.Kevin;
3
4 public class HelloWorld {
5
6 public static void main(String[] args) {
7
8 int a = 0;
9 int result = divide(5, a);
10 System.out.printf("divide(%d, %d) = %d", 5, a, result);
11 }
12
13 public static int divide(int number, int divisor) {
14
15 try {
16 return number / divisor;
17 } catch (Throwable throwable) {
18
19 System.out.println("getMessage() : " + throwable.getMessage());
20
21 System.out.println("toString() : " + throwable.toString());
22
23 System.out.println("printStackTrace()输出信息如下：");
24 throwable.printStackTrace();
25 }
26
27 return 0;
28 }
29 }
运行结果如下：
getMessage() : / by zero
toString() : java.lang.ArithmeticException: / by zero
printStackTrace()输出信息如下：
java.lang.ArithmeticException: / by zero
at com.Kevin.HelloWorld.divide(HelloWorld.java:17)
at com.Kevin.HelloWorld.main(HelloWorld.java:10)
divide(5, 0) = 0
将可以发生异常的语句System.out.println(5 / a)放到try-catch代码块中，称为捕获异常，有关捕获异常的相关知识会在下部分详细介绍。在catch中有一个Throwable对象throwable，throwable对象是系统在程序发生异常时创建，通过throwable对象可以调用Throwable中定义的方法。
代码第19行是调用getMessage()方法获得异常消息，输出结果是“/ by zero”。代码第21行是调用toString()方法获得异常对象的描述，输出结果是java.lang.ArithmeticException: / by zero。代码第24行是调用printStackTrace()方法打印异常堆栈跟踪信息。
Tips： 堆栈跟踪信息从下往上，是方法调用的顺序。首先JVM调用是 com.Kevin.HelloWorld 类的main方法，接着在HelloWorld.java源代码第10行调用 com.Kevin.HelloWorld 类的 divide 方法，在HelloWorld.java 源代码第17行发生了异常，最后输出的是异常信息。
2.2 Error 和 Exception
从Java异常类继承层次图可见，Throwable有两个直接子类：Error和Exception。
-
Error：Error 是程序无法恢复的严重错误，程序员根本无能为力，只能让程序终止。例如：JVM内部错误、内存溢出和资源耗尽等严重情况。
-
Exception：Exception 是程序可以恢复的异常，它是程序员所能掌控的。例如：除零异常、空指针访问、网络连接中断和读取不存在的文件等。本章所讨论的异常处理就是对Exception及其子类的异常处理。
2.3 受检查异常和运行时异常
从Java异常类层次图可见，Exception类可以分为：受检查异常和运行时异常。
-
受检查异常
如Java异常类层次图所示，受检查异常是除 RuntimeException 以外的异常类。它们的共同特点是：编译器会检查这类异常是否进行了处理，即要么捕获（try-catch语句），要么不抛出（通过在方法后声明throws），否则会发生编译错误。它们种类很多，前面遇到过的日期解析异常 ParseException。
-
运行时异常
运行时异常是继承 RuntimeException 类的直接或间接子类。运行时异常往往是程序员所犯错误导致的，健壮的程序不应该发生运行时异常。它们的共同特点是：编译器不检查这类异常是否进行了处理，也就是对于这类异常不捕获也不抛出，程序也可以编译通过。由于没有进行异常处理，一旦运行时异常发生就会导致程序的终止，这是用户不希望看到的。由于2.1部分除零示例的ArithmeticException异常属于RuntimeException异常，如Java异常类层次图所示，可以不用加try-catch语句捕获异常。
//HelloWorld.java文件
package com.Kevin;
public class HelloWorld {
public static void main(String[] args) {
int a = 0;
int result = divide(5, a);
System.out.printf("divide(%d, %d) = %d", 5, a, result);
}
public static int divide(int number, int divisor) {
//判断除数divisor非零，防止运行时异常
if (divisor != 0) {
return number / divisor;
}
return 0;
}
}
Tips： 对于运行时异常通常不采用抛出或捕获处理方式，而是应该提前预判，防止这种发生异常，做到未雨绸缪。例如2.1部分除零示例，在进行除法运算之前应该判断除数是非零的，修改示例代码如下，从代码可见提前预判这样处理要比通过try-catch捕获异常要友好的多。
2.4 Java常用内置异常
Java 语言定义了一些异常类在 java.lang 标准包中。标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。Java 根据各个类库也定义了一些其他的异常，下面的表中列出了 Java 的非检查性异常。
下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。
Tips：
- 检查性异常: 不处理编译不能通过
- 非检查性异常:不处理编译可以通过，如果有抛出直接抛到控制台
- 运行时异常: 就是非检查性异常
- 非运行时异常: 就是检查性异常
5.常见异常方法
下面的列表是 Throwable 类的主要方法:
6.通用异常
在Java中定义了两种类型的异常和错误。
- JVM(Java虚拟机) 异常：由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
- 程序级异常：由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。
三、捕获异常
在学习本内容之前，你先考虑一下，在现实生活中是如何对待领导交给你的任务呢？当然无非是两种：自己有能解决的自己处理；自己无力解决的反馈给领导，让领导自己处理。
那么对待受检查异常亦是如此。当前方法有能力解决，则捕获异常进行处理；没有能力解决，则抛出给上层调用方法处理。如果上层调用方法还无力解决，则继续抛给它的上层调用方法，异常就是这样向上传递直到有方法处理它，如果所有的方法都没有处理该异常，那么JVM会终止程序运行。
3.1 try-catch 语句
捕获异常是通过try-catch语句实现的，最基本try-catch语句语法如下：
try{
//可能会发生异常的语句
} catch(Throwable e){
//处理异常e
}
每个try代码块可以伴随一个或多个catch代码块，用于处理try代码块中所可能发生的多种异常。catch(Throwable e)语句中的e是捕获异常对象，e必须是Throwable的子类，异常对象e的作用域在该catch代码块中。下面看看一个try-catch示例：
1 //HelloWorld.java文件
2 package com.Kevin;
3
4 import java.text.DateFormat;
5 import java.text.ParseException;
6 import java.text.SimpleDateFormat;
7 import java.util.Date;
8
9 public class HelloWorld {
10
11 public static void main(String[] args) {
12 Date date = readDate();
13 System.out.println("日期 = " + date);
14 }
15
16 // 解析日期
17 public static Date readDate() {
18
19 try {
20 String str = "2018-4-28"; //"201A-18-18"
21 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
22 // 从字符串中解析日期
23 Date date = df.parse(str);
24 return date;
25 } catch (ParseException e) {
26 System.out.println("处理ParseException…");
27 e.printStackTrace();
28 }
29 return null;
30 }
31 }
上述代码第17行定义了一个静态方法用来将字符串解析成日期，但并非所有的字符串都是有效的日期字符串，因此调用代码第23行的解析方法parse()有可能发生ParseException异常，ParseException是受检查异常，在本例中使用try-catch捕获。代码第25行的e就是ParseException对象。代码第27行e.printStackTrace()是打印异常堆栈跟踪信息，本例中的"2018-4-28"字符串是有个有效的日期字符串，因此不会发生异常。如果将字符串改为无效的日期字符串，如"201A-18-18"，则会打印信息。
处理ParseException
java.text.ParseException: Unparseable date: "201A-18-18"
日期 = null
at java.text.DateFormat.parse(Unknown Source)
at com.Kevin.HelloWorld.readDate(HelloWorld.java:24)
at com.Kevin.HelloWorld.main(HelloWorld.java:13)
Tips： 静态方法、实例方法和构造方法都可以声明抛出异常，凡是抛出异常的方法都可以通过try-catch进行捕获，当然运行时异常可以不捕获。一个方法声明抛出什么样的异常需要查询API文
3.2 多catch代码块
如果try代码块中有很多语句会发生异常，而且发生的异常种类又很多。那么可以在try后面跟有多个catch代码块。多catch代码块语法如下：
try{
//可能会发生异常的语句
} catch(Throwable e){
//处理异常e
} catch(Throwable e){
//处理异常e
} catch(Throwable e){
//处理异常e
}
在多个catch代码情况下，当一个catch代码块捕获到一个异常时，其他的catch代码块就不再进行匹配。
Tips： 当捕获的多个异常类之间存在父子关系时，捕获异常顺序与catch代码块的顺序有关。一般先捕获子类，后捕获父类，否则子类捕获不到。
示例代码如下：
1 //HelloWorld.java文件
2 package com.Kevin;
3
4 ……
5
6 public class HelloWorld {
7
8 public static void main(String[] args) {
9 Date date = readDate();
10 System.out.println("读取的日期 = " + date);
11 }
12
13 public static Date readDate() {
14
15 FileInputStream readfile = null;
16 InputStreamReader ir = null;
17 BufferedReader in = null;
18 try {
19 readfile = new FileInputStream("readme.txt");
20 ir = new InputStreamReader(readfile);
21 in = new BufferedReader(ir);
22 // 读取文件中的一行数据
23 String str = in.readLine();
24 if (str == null) {
25 return null;
26 }
27
28 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
29 Date date = df.parse(str);
30 return date;
31
32 } catch (FileNotFoundException e) {
33 System.out.println("处理FileNotFoundException...");
34 e.printStackTrace();
35 } catch (IOException e) {
36 System.out.println("处理IOException...");
37 e.printStackTrace();
38 } catch (ParseException e) {
39 System.out.println("处理ParseException...");
40 e.printStackTrace();
41 }
42 return null;
43 }
44
45 }
上述代码通过Java I/O（输入输出）流技术从文件readme.txt中读取字符串，然后解析成为日期。由于Java I/O技术还没有介绍，读者先不要关注I/O技术细节，这考虑调用它们的方法会发生异常就可以了。
在try代码块中第19行代码调用FileInputStream构造方法可以会发生FileNotFoundException异常。第23行代码调用BufferedReader输入流的readLine()方法可以会发生IOException异常。从Java异常类继承层次图可见FileNotFoundException异常是IOException异常的子类，应该先FileNotFoundException捕获，见代码第32行；后捕获IOException，见代码第35行。
如果将FileNotFoundException和IOException捕获顺序调换，代码如下：
try{
//可能会发生异常的语句
} catch (IOException e) {
// IOException异常处理
} catch (FileNotFoundException e) {
// FileNotFoundException异常处理
}
那么第二个catch代码块永远不会进入，FileNotFoundException异常处理永远不会执行。
由于上述代码第38行ParseException异常与IOException和FileNotFoundException异常没有父子关系，捕获ParseException异常位置可以随意放置。
3.3 try-catch 语句嵌套
Java提供的try-catch语句嵌套是可以任意嵌套，修改3.2部分示例代码如下：
1 //HelloWorld.java文件
2 package com.Kevin;
3 … …
4 public class HelloWorld {
5
6 public static void main(String[] args) {
7 Date date = readDate();
8 System.out.println("读取的日期 = " + date);
9 }
10
11 public static Date readDate() {
12
13 FileInputStream readfile = null;
14 InputStreamReader ir = null;
15 BufferedReader in = null;
16 try {
17 readfile = new FileInputStream("readme.txt");
18 ir = new InputStreamReader(readfile);
19 in = new BufferedReader(ir);
20
21 try {
22 String str = in.readLine();
23 if (str == null) {
24 return null;
25 }
26
27 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
28 Date date = df.parse(str);
29 return date;
30
31 } catch (ParseException e) {
32 System.out.println("处理ParseException...");
33 e.printStackTrace();
34 }
35
36 } catch (FileNotFoundException e) {
37 System.out.println("处理FileNotFoundException...");
38 e.printStackTrace();
39 } catch (IOException e) {
40 System.out.println("处理IOException...");
41 e.printStackTrace();
42 }
43 return null;
44 }
45 }
上述代码第21~34行是捕获ParseException异常try-catch语句，可见这个try-catch语句就是嵌套在捕获IOException和FileNotFoundException异常的try-catch语句中。
程序执行时内层如果会发生异常，首先由内层catch进行捕获，如果捕获不到，则由外层catch捕获。例如：代码第22行的readLine()方法可能发生IOException异常，该异常无法被内层catch捕获，最后被代码第39行的外层catch捕获。
Tips： try-catch不仅可以嵌套在try代码块中，还可以嵌套在catch代码块或finally代码块，finally代码块后面会详细介绍。try-catch嵌套会使程序流程变的复杂，如果能用多catch捕获的异常，尽量不要使用try-catch嵌套。特别对于初学者不要简单地使用Eclipse的语法提示不加区分地添加try-catch嵌套，要梳理好程序的流程再考虑try-catch嵌套的必要性。
3.4 多重捕捉
多catch代码块客观上提高了程序的健壮性，但是程序代码量大大增加。如果有些异常虽然种类不同，但捕获之后的处理是相同的，看如下代码。
try{
//可能会发生异常的语句
} catch (FileNotFoundException e) {
//调用方法methodA处理
} catch (IOException e) {
//调用方法methodA处理
} catch (ParseException e) {
//调用方法methodA处理
}
三个不同类型的异常，要求捕获之后的处理都是调用methodA方法。是否可以把这些异常合并处理，Java 7推出了多重捕获（multi-catch）技术，可以帮助解决此类问题，上述代码修改如下：
try{
//可能会发生异常的语句
} catch (IOException | ParseException e) {
//调用方法methodA处理
}
在catch中多重捕获异常用“|”运算符连接起来。
Tips： 有的读者会问什么不写成FileNotFoundException | IOException | ParseException 呢？这是因为由于FileNotFoundException属于IOException异常，IOException异常可以捕获它的所有子类异常了。
四、释放资源
有时在try-catch语句中会占用一些非Java资源，如：打开文件、网络连接、打开数据库连接和使用数据结果集等，这些资源并非Java资源，不能通过JVM的垃圾收集器回收，需要程序员释放。为了确保这些资源能够被释放可以使用finally代码块或Java 7之后提供自动资源管理（Automatic Resource Management）技术。
4.1 finally 代码块
try-catch语句后面还可以跟有一个finally代码块，try-catch-finally语句语法如下：
try{
//可能会生成异常语句
} catch(Throwable e1){
//处理异常e1
} catch(Throwable e2){
//处理异常e2
} catch(Throwable eN){
//处理异常eN
} finally{
//释放资源
}
无论try正常结束还是catch异常结束都会执行finally代码块，如下图所示：
使用finally代码块示例代码如下：
1 //HelloWorld.java文件
2 package com.Kevin;
3
4 … …
5
6 public class HelloWorld {
7
8 public static void main(String[] args) {
9 Date date = readDate();
10 System.out.println("读取的日期 = " + date);
11 }
12
13 public static Date readDate() {
14
15 FileInputStream readfile = null;
16 InputStreamReader ir = null;
17 BufferedReader in = null;
18 try {
19 readfile = new FileInputStream("readme.txt");
20 ir = new InputStreamReader(readfile);
21 in = new BufferedReader(ir);
22 // 读取文件中的一行数据
23 String str = in.readLine();
24 if (str == null) {
25 return null;
26 }
27
28 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
29 Date date = df.parse(str);
30 return date;
31
32 } catch (FileNotFoundException e) {
33 System.out.println("处理FileNotFoundException...");
34 e.printStackTrace();
35 } catch (IOException e) {
36 System.out.println("处理IOException...");
37 e.printStackTrace();
38 } catch (ParseException e) {
39 System.out.println("处理ParseException...");
40 e.printStackTrace();
41 } finally {
42 try {
43 if (readfile != null) {
44 readfile.close();
45 }
46 } catch (IOException e) {
47 e.printStackTrace();
48 }
49 try {
50 if (ir != null) {
51 ir.close();
52 }
53 } catch (IOException e) {
54 e.printStackTrace();
55 }
56 try {
57 if (in != null) {
58 in.close();
59 }
60 } catch (IOException e) {
61 e.printStackTrace();
62 }
63 }
64
65 return null;
66 }
67 }
上述代码第41行~第63行是finally语句，在这里通过关闭流释放资源，FileInputStream、InputStreamReader和BufferedReader是三个输入流，它们都需要关闭，见代码第44行~第58行通过流的close()关闭流，但是流的close()方法还有可以能发生 IOException 异常，所以这里又针对每一个close()语句还需要进行捕获处理。
Tips： 为了代码简洁等目的，可能有的人会将finally代码中的多个嵌套的try-catch语句合并，例如将上述代码改成如下形式，将三个有可以发生异常的close()方法放到一个try-catch。读者自己考虑一下这处理是否稳妥呢？每一个close()方法对应关闭一个资源，如果第一个close()方法关闭时发生了异常，那么后面的两个也不会关闭，因此如下的程序代码是有缺陷的。
try {
... ...
} catch (FileNotFoundException e) {
... ...
} catch (IOException e) {
... ...
} catch (ParseException e) {
... ...
} finally {
try {
if (readfile != null) {
readfile.close();
}
if (ir != null) {
ir.close();
}
if (in != null) {
in.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
4.2 自动资源管理
4.1部分使用finally代码块释放资源会导致程序代码大量增加，一个finally代码块往往比正常执行的程序还要多。在Java 7之后提供自动资源管理（Automatic Resource Management）技术，可以替代finally代码块，优化代码结构，提高程序可读性。自动资源管理是在try语句上的扩展，语法如下：
try (声明或初始化资源语句) {
//可能会生成异常语句
} catch(Throwable e1){
//处理异常e1
} catch(Throwable e2){
//处理异常e1
} catch(Throwable eN){
//处理异常eN
}
在try语句后面添加一对小括号“()”，其中是声明或初始化资源语句，可以有多条语句语句之间用分号“;”分隔。
示例代码如下：
1 //HelloWorld.java文件
2 package com.Kevin;
3 … …
4 public class HelloWorld {
5
6 public static void main(String[] args) {
7 Date date = readDate();
8 System.out.println("读取的日期 = " + date);
9 }
10
11 public static Date readDate() {
12
13 // 自动资源管理
14 try (FileInputStream readfile = new FileInputStream("readme.txt");
15 InputStreamReader ir = new InputStreamReader(readfile);
16 BufferedReader in = new BufferedReader(ir)) {
17
18 // 读取文件中的一行数据
19 String str = in.readLine();
20 if (str == null) {
21 return null;
22 }
23
24 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
25 Date date = df.parse(str);
26 return date;
27
28 } catch (FileNotFoundException e) {
29 System.out.println("处理FileNotFoundException...");
30 e.printStackTrace();
31 } catch (IOException e) {
32 System.out.println("处理IOException...");
33 e.printStackTrace();
34 } catch (ParseException e) {
35 System.out.println("处理ParseException...");
36 e.printStackTrace();
37 }
38
39 return null;
40 }
41
42 }
上述代码第14行~第16行是声明或初始化三个输入流，三条语句放到在try语句后面小括号中，语句之间用分号“;”分隔，这就是自动资源管理技术了，采用了自动资源管理后不再需要finally代码块，不需要自己close这些资源，释放过程交给了JVM。
Tips： 所有可以自动管理的资源需要实现AutoCloseable接口，上述代码中三个输入流FileInputStream、InputStreamReader和BufferedReader从Java 7之后实现AutoCloseable接口，具体哪些资源实现AutoCloseable接口需要查询API文档。
五、throw 与声明方法抛出异常
在一个方法中如果能够处理异常，则需要捕获并处理。但是本方法没有能力处理该异常，捕获它没有任何意义，则需要在方法后面声明抛出该异常，通知上层调用者该方法有可以发生异常。
方法后面声明抛出使用throws关键字，成员方法语法格式如下：
class className {
[public | protected | private ] [static] [final | abstract] [native] [synchronized]
type methodName([paramList]) [throws exceptionList] {
//方法体
}
}
其中参数列表之后的[throws exceptionList]语句是声明抛出异常。方法中可能抛出的异常（除了Error和RuntimeException及其子类外）都必须通过throws语句列出，多个异常之间采用逗号（,）分隔。
Tips： 如果声明抛出的多个异常类之间有父子关系，可以只声明抛出父类。但如果没有父子关系情况下，最好明确声明抛出每一个异常，因为上层调用者会根据这些异常信息进行相应的处理。假如一个方法中有可能抛出IOException和ParseException两个异常，那么声明抛出IOException和ParseException呢？还是只声明抛出Exception呢？因为Exception是IOException和ParseException的父类，只声明抛出Exception从语法是允许的，但是声明抛出IOException和ParseException更好一些。
如果将第三部分中的示例进行修改，在readDate()方法后声明抛出异常，代码如下：
1 //HelloWorld.java文件
2 package com.Kevin;
3
4 … …
5 public class HelloWorld {
6
7 public static void main(String[] args) {
8
9 try {
10 Date date = readDate();
11 System.out.println("读取的日期 = " + date);
12 } catch (IOException e) {
13 System.out.println("处理IOException...");
14 e.printStackTrace();
15 } catch (ParseException e) {
16 System.out.println("处理ParseException...");
17 e.printStackTrace();
18 }
19
20 }
21
22 public static Date readDate() throws IOException, ParseException {
23
24 // 自动资源管理
25 FileInputStream readfile = new FileInputStream("readme.txt");
26 InputStreamReader ir = new InputStreamReader(readfile);
27 BufferedReader in = new BufferedReader(ir);
28
29 // 读取文件中的一行数据
30 String str = in.readLine();
31 if (str == null) {
32 return null;
33 }
34
35 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
36 Date date = df.parse(str);
37 return date;
38 }
39
40 }
由于readDate()方法中代码第25、30、36行都有可能引发异常。在readDate()方法内又没有捕获处理，所有需要在代码第22行方法后声明抛出异常，事实上有三个异常FileNotFoundException、IOException和ParseException，由于FileNotFoundException属于IOException异常，所以只声明IOException和ParseException就可以了。
一旦readDate()方法声明抛出了异常，那么它的调用者main()方法，也会面临同样的问题：要么捕获自己处理，要么抛出给上层调用者。如果一旦发生异常main()方法也选择抛出那么程序运行就会终止。本例中main()方法是捕获异常进行处理，捕获异常过程前面已经介绍过了，这里不再赘述。
六、自定义异常类
有些公司为了提高代码的可重用性，自己开发了一些Java类库或框架，其中少不了自己编写了一些异常类。实现自定义异常类需要继承Exception类或其子类，如果自定义运行时异常类需继承RuntimeException类或其子类。实现自定义异常类示例代码如下：
1 package com.Kevin;
2
3 public class MyException extends Exception {
4
5 public MyException() {
6
7 }
8
9 public MyException(String message) {
10 super(message);
11 }
12
13 }
上述代码实现了自定义异常，自定义异常类一般需要提供两个构造方法，一个是代码第5行的无参数的默认构造方法，异常描述信息是空的；另一个是代码第9行的字符串参数的构造方法，message是异常描述信息，getMessage()方法可以获得这些信息。自定义异常就这样简单，主要是提供两个构造方法就可以了。
七、throw 与显式抛出异常
Java异常相关的关键字中有两个非常相似，它们是throws和throw，其中throws关键字前面第五部分已经介绍了，throws用于方法后声明抛出异常，而throw关键字用来人工引发异常。本节之前读者接触到的异常都是由于系统生成的，当异常发生时，系统会生成一个异常对象，并将其抛出。但也可以通过throw语句显式抛出异常，语法格式如下：
throw Throwable或其子类的实例
所有Throwable或其子类的实例都可以通过throw语句抛出。
显式抛出异常目的有很多，例如不想某些异常传给上层调用者，可以捕获之后重新显式抛出另外一种异常给调用者。
修改第四部分节示例代码如下：
1 //HelloWorld.java文件
2 package com.Kevin;
3 … …
4 public class HelloWorld {
5
6 public static void main(String[] args) {
7 try {
8 Date date = readDate();
9 System.out.println("读取的日期 = " + date);
10 } catch (MyException e) {
11 System.out.println("处理MyException...");
12 e.printStackTrace();
13 }
14 }
15
16 public static Date readDate() throws MyException {
17
18 // 自动资源管理
19 try (FileInputStream readfile = new FileInputStream("readme.txt");
20 InputStreamReader ir = new InputStreamReader(readfile);
21 BufferedReader in = new BufferedReader(ir)) {
22
23 // 读取文件中的一行数据
24 String str = in.readLine();
25 if (str == null) {
26 return null;
27 }
28
29 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
30 Date date = df.parse(str);
31 return date;
32
33 } catch (FileNotFoundException e) {
34 throw new MyException(e.getMessage());
35 } catch (IOException e) {
36 throw new MyException(e.getMessage());
37 } catch (ParseException e) {
38 System.out.println("处理ParseException...");
39 e.printStackTrace();
40 }
41 return null;
42 }
43 }
如果软件设计者不希望readDate()方法中捕获的FileNotFoundException和IOException异常出现在main()方法（上层调用者）中，那么可以在捕获到FileNotFoundException和IOException异常时，通过throw语句显式抛出一个异常，见代码第34行和第36行throw new MyException(e.getMessage())语句，MyException是自定义的异常。
Tips： throw显式抛出的异常与系统生成并抛出的异常，在处理方式上没有区别，就是两种方法：要么捕获自己处理，要么抛出给上层调用者。在本例中是声明抛出，所以在readDate()方法后面要声明抛出MyException异常。
来源：https://www.cnblogs.com/Kevin-ZhangCG/p/8967534.html