达者为先师者之意
Java 异常处理
- 1 异常简介
- 2 异常类型
- 3 异常处理机制
- 4 try catch语句详解
-
- 4.1 捕获异常
- 4.2 多重catch语句
- 5 try catch finally语句详解
- 6 finally与return的执行顺序
-
- 6.1 try 和 catch 中带有 return
- 6.2 finally 中带有 return
- 6.3 finally 改变返回值
- 7 声明和抛出异常
-
- 7.1 throws 声明异常
-
- 7.1.1 throws 具体格式如下：
- 7.1.2 重写方法时，声明抛出异常限制
- 7.2 throw 抛出异常
- 8 自定义异常
1 异常简介
Java 异常，又称例外，是程序执行过程中发生的事件，中断了执行过程中的正常指令流。为了及时有效地处理程序中的操作错误，必须使用异常类，使程序具有良好的容错性和更强的力量。
在 Java 产生异常有三个主要原因：
- Java 内部错误发生异常，Java 虚拟机产生的异常。
- 编写的程序代码中的错误，如空指针异常、数组越界异常等。
- 通过 throw 语句手动生成的异常通常用于告知调用者该方法的必要信息。
Java 通过面向对象的方法来处理异常。在一种方法的运行过程中，如果出现异常，该方法将产生代表异常的对象，并将其交给运行过程中的系统，以找到相应的代码来处理异常。
我们称生成异常对象并提交给运行系统的过程为抛出（throw）异常。在运行过程中，系统在方法的调用栈中搜索，直到找到可以处理这类异常的对象。这个过程被称为捕获（catch）异常。
为了更好地理解什么是异常，下面是一个非常简单的段落 Java 程序。以下示例代码允许用户输入 1~3 其他情况表明输入错误。
import java.util.Scanner; public class Test01 {
public static void main(String[] args) {
System.out.println("请输入您的选择:(1)~3 之间的整数)"); Scanner input = new Scanner(System.in); int num = input.nextInt(); switch (num) {
case 1: System.out.println("one"); break; case 2: System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("error");
break;
}
}
}
正常情况下，用户会按照系统的提示输入 1~3 之间的数字。但是，如果用户没有按要求进行输入，例如输入了一个字母“a”，则程序在运行时将会发生异常，运行结果如下所示。
请输入您的选择：（1~3 之间的整数）
a
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Unknown Source)
at java.util.Scanner.next(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at text.text.main(text.java:11)
2 异常类型
为了能够及时有效地处理程序中的运行错误，Java 专门引入了异常类。在 Java 中所有异常类型都是内置类 java.lang.Throwable 类的子类，即 Throwable 位于异常类层次结构的顶层。Throwable 类下有两个异常分支 Exception 和 Error，如下图所示。
由图 可以知道，Throwable 类是所有异常和错误的超类，下面有 Error 和 Exception 两个子类分别表示错误和异常。其中异常类 Exception 又分为运行时异常和非运行时异常，这两种异常有很大的区别，也称为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。
- Exception 类用于用户程序可能出现的异常情况，它也是用来创建自定义异常类型类的类。
- Error 定义了在通常环境下不希望被程序捕获的异常。一般指的是 JVM 错误，如堆栈溢出。
本节不讨论关于 Error 类型的异常处理，因为它们通常是灾难性的致命错误，不是程序可以控制的。接下来将讨论 Exception 类型的异常处理。
运行时异常都是 RuntimeException 类及其子类异常，如 NullPointerException、IndexOutOfBoundsException 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般由程序逻辑错误引起，程序应该从逻辑角度尽可能避免这类异常的发生。
非运行时异常是指 RuntimeException 以外的异常，类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如 IOException、ClassNotFoundException 等以及用户自定义的 Exception 异常（一般情况下不自定义检查异常）。
表 1 和表 2 分别列出了 java.lang 中定义的运行时异常和非运行时异常的类型及作用。
3 异常处理机制
Java 的异常处理通过 5 个关键字来实现：try、catch、throw、throws 和 finally。try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。
本节先主要介绍异常处理的机制及基本的语句结构。
Java 的异常处理机制提供了一种结构性和控制性的方式来处理程序执行期间发生的事件。异常处理的机制如下： 在方法中用 try catch 语句捕获并处理异常，catch 语句可以有多个，用来匹配多个异常。 对于处理不了的异常或者要转型的异常，在方法的声明处通过 throws 语句拋出异常，即由上层的调用方法来处理。
以下代码是异常处理程序的基本结构：
try {
逻辑程序块
} catch(ExceptionType1 e) {
处理代码块1
} catch (ExceptionType2 e) {
处理代码块2
throw(e); // 再抛出这个"异常"
} finally {
释放资源代码块
}
4 try catch语句详解
4.1 捕获异常
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。 在 Java 中通常采用 try catch 语句来捕获异常并处理。语法格式如下：
try {
// 可能发生异常的语句
} catch(ExceptionType e) {
// 处理异常语句
}
在以上语法中，把可能引发异常的语句封装在 try 语句块中，用以捕获可能发生的异常。catch 后的( )里放匹配的异常类，指明 catch 语句可以处理的异常类型，发生异常时产生异常类的实例化对象。
如果 try 语句块中发生异常，那么一个相应的异常对象就会被拋出，然后 catch 语句就会依据所拋出异常对象的类型进行捕获，并处理。处理之后，程序会跳过 try 语句块中剩余的语句，转到 catch 语句块后面的第一条语句开始执行。
如果 try 语句块中没有异常发生，那么 try 块正常结束，后面的 catch 语句块被跳过，程序将从 catch 语句块后的第一条语句开始执行。
注意：try…catch 与 if…else 不一样，try 后面的花括号{ }不可以省略，即使 try 块里只有一行代码，也不可省略这个花括号。与之类似的是，catch 块后的花括号{ }也不可以省略。另外，try 块里声明的变量只是代码块内的局部变量，它只在 try 块内有效，其它地方不能访问该变量。
在上面语法的处理代码块 1 中，可以使用以下 3 个方法输出相应的异常信息。
- printStackTrace() 方法：指出异常的类型、性质、栈层次及出现在程序中的位置。
- getMessage() 方法：输出错误的性质。
- toString() 方法：给出异常的类型与性质。
实例 下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第四个元素的时候就会抛出一个异常。
ExcepTest.java 文件代码：
// 文件名 : ExcepTest.java
import java.io.*;
public class ExcepTest{
public static void main(String args[]){
try{
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}
/* 以上代码编译运行输出结果如下： Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 Out of the block */
编写一个录入学生姓名、年龄和性别的程序，要求能捕捉年龄不为数字时的异常。在这里使用 try catch 语句来实现，具体代码如下：
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("---------学生信息录入---------------");
String name = ""; // 获取学生姓名
int age = 0; // 获取学生年龄
String sex = ""; // 获取学生性别
try {
System.out.println("请输入学生姓名：");
name = scanner.next();
System.out.println("请输入学生年龄：");
age = scanner.nextInt();
System.out.println("请输入学生性别：");
sex = scanner.next();
} catch (Exception e) {
e.printStackTrace();
System.out.println("输入有误！");
}
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
}
}
上述代码在 main() 方法中使用 try catch 语句来捕获异常，将可能发生异常的age = scanner.nextlnt();代码放在了 try 块中，在 catch 语句中指定捕获的异常类型为 Exception，并调用异常对象的 printStackTrace() 方法输出异常信息。运行结果如下所示。
---------学生信息录入---------------
请输入学生姓名：
徐白
请输入学生年龄：
110a
java.util.InputMismatchException
at java.util.Scanner.throwFor(Unknown Source)
at java.util.Scanner.next(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
输入有误！
姓名：徐白
年龄：0
at text.text.main(text.java:19)
4.2 多重catch语句
如果 try 代码块中有很多语句会发生异常，而且发生的异常种类又很多。那么可以在 try 后面跟有多个 catch 代码块。多 catch 代码块语法如下：
try {
// 可能会发生异常的语句
} catch(ExceptionType e) {
// 处理异常语句
} catch(ExceptionType e) {
// 处理异常语句
} catch(ExceptionType e) {
// 处理异常语句
...
}
在多个 catch 代码块的情况下，当一个 catch 代码块捕获到一个异常时，其它的 catch 代码块就不再进行匹配。
注意：当捕获的多个异常类之间存在父子关系时，捕获异常时一般先捕获子类，再捕获父类。所以子类异常必须在父类异常的前面，否则子类捕获不到。
public class Test03 {
public static void main(String[] args) {
Date date = readDate();
System.out.println("读取的日期 = " + date);
}
public static Date readDate() {
FileInputStream readfile = null;
InputStreamReader ir = null;
BufferedReader in = null;
try {
readfile = new FileInputStream("readme.txt");
ir = new InputStreamReader(readfile);
in = new BufferedReader(ir);
// 读取文件中的一行数据
String str = in.readLine();
if (str == null) {
return null;
}
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date date = df.parse(str);
return date;
} catch (FileNotFoundException e) {
System.out.println("处理FileNotFoundException...");
e.printStackTrace();
} catch (IOException e) {
System.out.println("处理IOException...");
e.printStackTrace();
} catch (ParseException e) {
System.out.println("处理ParseException...");
e.printStackTrace();
}
return null;
}
}
上述代码通过 Java I/O（输入输出）流技术从文件 readme.txt 中读取字符串，然后解析成为日期。由于 Java I/O 技术还没有介绍，大家先不要关注 I/O 技术细节，只看调用它们时方法会发生的异常就可以了。
在 try 代码块中第 12 行代码调用 FileInputStream 构造方法可能会发生 FileNotFoundException 异常。第 16 行代码调用 BufferedReader 输入流的 readLine() 方法可能会发生 IOException 异常。FileNotFoundException 异常是 IOException 异常的子类，应该先捕获 FileNotFoundException 异常，见代码第 23 行；后捕获 IOException 异常，见代码第 26 行。
如果将 FileNotFoundException 和 IOException 捕获顺序调换，那么捕获 FileNotFoundException 异常代码块将永远不会进入，FileNotFoundException 异常处理永远不会执行。 上述代码第 29 行 ParseException 异常与 IOException 和 FileNotFoundException 异常没有父子关系，所以捕获 ParseException 异常位置可以随意放置。
5 try catch finally语句详解
在实际开发中，根据 try catch 语句的执行过程，try 语句块和 catch 语句块有可能不被完全执行，而有些处理代码则要求必须执行。例如，程序在 try 块里打开了一些物理资源（如数据库连接、网络连接和磁盘文件等），这些物理资源都必须显式回收。 Java的垃圾回收机制不会回收任何物理资源，垃圾回收机制只回收堆内存中对象所占用的内存。
所以为了确保一定能回收 try 块中打开的物理资源，异常处理机制提供了 finally 代码块，并且 Java 7 之后提供了自动资源管理（Automatic Resource Management）技术。
- finally 关键字用来创建在 try 代码块后面执行的代码块。
- 无论是否发生异常，finally 代码块中的代码总会被执行。
- 在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
- finally 代码块出现在 catch 代码块最后
finally 语句可以与前面介绍的 try catch 语句块匹配使用，语法格式如下：
try {
// 可能会发生异常的语句
} catch(ExceptionType e) {
// 处理异常语句
} finally {
// 清理代码块
}
对于以上格式，无论是否发生异常（除特殊情况外），finally 语句块中的代码都会被执行。此外，finally 语句也可以和 try 语句匹配使用，其语法格式如下：
try {
// 逻辑代码块
} finally {
// 清理代码块
}
使用 try-catch-finally 语句时需注意以下几点：
- 异常处理语法结构中只有 try 块是必需的，也就是说，如果没有 try 块，则不能有后面的 catch 块和 finally 块；
- catch 块和 finally 块都是可选的，但 catch 块和 finally 块至少出现其中之一，也可以同时出现；
- 可以有多个 catch 块，捕获父类异常的 catch 块必须位于捕获子类异常的后面；
- 不能只有 try 块，既没有 catch 块，也没有 finally 块；
- 多个 catch 块必须位于 try 块之后，finally 块必须位于所有的 catch 块之后。
- finally 与 try 语句块匹配的语法格式，此种情况会导致异常丢失，所以不常见。
一般情况下，无论是否有异常拋出，都会执行 finally 语句块中的语句，执行流程如下图所示。
try catch finally 语句块的执行情况可以细分为以下 3 种情况：
- 如果 try 代码块中没有拋出异常，则执行完 try 代码块之后直接执行 finally 代码块，然后执行 try catch finally 语句块之后的语句。
- 如果 try 代码块中拋出异常，并被 catch 子句捕捉，那么在拋出异常的地方终止 try 代码块的执行，转而执行相匹配的 catch 代码块，之后执行 finally 代码块。如果 finally 代码块中没有拋出异常，则继续执行 try catch finally 语句块之后的语句；如果 finally 代码块中拋出异常，则把该异常传递给该方法的调用者。
- 如果 try 代码块中拋出的异常没有被任何 catch 子句捕捉到，那么将直接执行 finally 代码块中的语句，并把该异常传递给该方法的调用者。
除非在 try 块、catch 块中调用了退出虚拟机的方法System.exit(int status)，否则不管在 try 块或者 catch 块中执行怎样的代码，出现怎样的情况，异常处理的 finally 块总会执行。
通常情况下不在 finally 代码块中使用 return 或 throw 等导致方法终止的语句，否则将会导致 try 和 catch 代码块中的 return 和 throw 语句失效。
当 Windows 系统启动之后，即使不作任何操作，在关机时都会显示“谢谢使用”。下面编写 Java 程序使用 try catch finally 语句这个过程，具体代码如下：
import java.util.Scanner;
public class Test04 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Windows 系统已启动！");
String[] pros = {
"记事本", "计算器", "浏览器" };
try {
// 循环输出pros数组中的元素
for (int i = 0; i < pros.length; i++) {
System.out.println(i + 1 + "：" + pros[i]);
}
System.out.println("是否运行程序：");
String answer = input.next();
if (answer.equals("y")) {
System.out.println("请输入程序编号：");
int no = input.nextInt();
System.out.println("正在运行程序[" + pros[no - 1] + "]");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("谢谢使用!");
}
}
}
上述代码在 main() 方法中使用 try catch finally 语句模拟了系统的使用过程。当系统启动之后显示提示语，无论是否运行了程序，或者在运行程序时出现了意外，程序都将执行 finally 块中的语句，即显示“谢谢使用！”。输出时的结果如下所示。
Windows 系统已启动！
1：记事本
2：计算器
3：浏览器
是否运行程序：
y
请输入程序编号：
2
正在运行程序[计算器]
谢谢使用!
Windows 系统已启动！
1：记事本
2：计算器
3：浏览器
是否运行程序：
y
请输入程序编号：
5
谢谢使用!
java.lang.ArrayIndexOutOfBoundsException: 4
at text.text.main(text.java:23)
Windows 系统已启动！
1：记事本
2：计算器
3：浏览器
是否运行程序：
asdfasd
谢谢使用!
再来个实例 ExcepTest.java 文件代码：
public class ExcepTest{
public static void main(String args[]){
int a[] = new int[2];
try{
System.out.println("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
finally{
a[0] = 6;
System.out.println("First element value: " +a[0]);
System.out.println("The finally statement is executed");
}
}
}
以上实例编译运行结果如下：
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed
注意下面事项：
- catch 不能独立于 try 存在。
- 在 try/catch 后面添加 finally 块并非强制性要求的。
- try 代码后不能既没 catch 块也没 finally 块。
- try, catch, finally 块之间不能添加任何代码。
6 finally与return的执行顺序
在 Java 的异常处理中，try、catch 和 finally 是按顺序执行的。如果 try 中没有异常，则顺序为 try→finally，如果 try 中有异常，则顺序为 try→catch→finally。但是当 try、catch、finally 中加入 return 之后，return 和 finally 的执行顺序让很多人混淆不清。下面来分别说明一下。
6.1 try 和 catch 中带有 return
- try 中带有 return
public class tryDemo {
public static int show() {
try {
return 1;
} finally {
System.out.println("执行finally模块");
}
}
public static void main(String args[]) {
System.out.println(show());
}
}
输出结果如下：
执行finally模块
1
- try 和 catch 中都带有 return
public class tryDemo {
public static int show() {
try {
int a = 8 / 0;
return 1;
} catch (Exception e) {
return 2;
} finally {