捕捉和处理异常
在Java中，我们使用异常处理程序组件try，catch和finally块来处理异常。
为了捕获和处理异常，我们将try...catch...finally代码块放置在可能产生异常的代码周围。finally块是可选的。
try...catch...finally的语法为：
try {
// 代码
} catch (ExceptionType e) {
// 捕获块
} finally {
//finally块
}Java try ... catch块
可能会生成异常的代码放在try块中。
每个try块后面应紧跟着catch 或 finally块。发生异常时，它会被catch紧随其后的块捕获。
catch块不能单独使用，必须紧随try块。
示例1：try ... catch块
class Main {
public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
System.out.println("try块中的其余代码");
} catch (ArithmeticException e) {
System.out.println("ArithmeticException => " + e.getMessage());
}
}
}输出结果
ArithmeticException => / by zero在这个实例中
我们在try块中将数字除以0。这产生一个ArithmeticException。
发生异常时，程序将跳过try块中的其余代码。
在这里，我们创建了一个catch块来处理ArithmeticException。因此，将catch执行块内的语句。
如果该try块中的所有语句均未生成异常，则跳过catch代码块。
多个捕获块
对于每个try块，可以有零个或多个catch块。
每个catch块的参数类型指示可以处理的异常类型。多个catch块使我们能够以不同方式处理每个异常。
示例2：多个捕获块
class ListOfNumbers {
public int[] arrayOfNumbers = new int[10];
public void writeList() {
try {
arrayOfNumbers[10] = 11;
} catch (NumberFormatException e1) {
System.out.println("NumberFormatException => " + e1.getMessage());
} catch (IndexOutOfBoundsException e2) {
System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
}
}
}
class Main {
public static void main(String[] args) {
ListOfNumbers list = new ListOfNumbers();
list.writeList();
}
}输出结果
IndexOutOfBoundsException => Index 10 out of bounds for length 10在此示例中，我们声明了一个大小为10 的整数数组arrayOfNumbers。
我们知道数组索引总是从0开始。因此，当我们尝试为索引10分配一个值时，就会发生IndexOutOfBoundsException，因为数组arrayOfNumbers的边界是0到9。
当try块中发生异常时：
异常被抛出给第一个catch块。第一个catch块不处理IndexOutOfBoundsException异常，因此它被传递给下一个catch块。
上面示例中的第二个catch块是适当的异常处理程序，因为它处理IndexOutOfBoundsException。 因此，它被执行。
Java Finally块
对于每个try块，只能有一个finally块。
finally块是可选的。但是，如果已定义，它将始终执行（即使不会发生异常）。
如果发生异常，则在try...catch块之后执行。如果没有异常发生，则在try块之后执行。
finally块的基本语法为：
try {
//code
} catch (ExceptionType1 e1) {
// catch 块
} catch (ExceptionType1 e2) {
// catch 块
} finally {
//finally块一直执行
}示例3：finally块示例
class Main {
public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
} catch (ArithmeticException e) {
System.out.println("ArithmeticException => " + e.getMessage());
} finally {
System.out.println("Finally块总是执行");
}
}
}输出结果
ArithmeticException => / by zero Finally块总是执行
在此示例中，我们将数字除以0。这引发了一个ArithmeticException被catch块捕获，finally块始终执行。
使用finally块被认为是一种很好的做法。这是因为它包含了重要的清理代码，例如
可能被return、continue或break语句意外跳过的代码
关闭文件或连接
我们已经提到，finally总是执行，通常是这样的。但是，在某些情况下，finally块不执行：
使用 System.exit()方法
finally块中发生异常
线程被终止
示例4：try, catch 和finally示例
让我们举一个实例，我们尝试使用FileWriter创建一个新文件，并使用PrintWriter写入数据。
import java.io.*;
class ListOfNumbers {
private int[] list = new int[10];
public ListOfNumbers() {
//在列表数组中存储整数值
for (int i = 0; i < 10; i++) {
list[i] = i;
}
}
}
public void writeList() {
PrintWriter out = null;
try {
System.out.println("进入try语句");
//创建一个新文件OutputFile.txt
out = new PrintWriter(new FileWriter("OutputFile.txt"));
//将值从列表数组写入新创建的文件
for (int i = 0; i < 10; i++) {
out.println("Value at: " + i + " = " + list[i]);
}
} catch (IndexOutOfBoundsException e1) {
System.out.println("IndexOutOfBoundsException => " + e1.getMessage());
} catch (IOException e2) {
System.out.println("IOException => " + e2.getMessage());
} finally {
//检查PrintWriter是否被打开
if (out != null) {
System.out.println("关闭PrintWriter");
out.close();
} else {
System.out.println("PrintWriter无法打开");
}
}
}
}
class Main {
public static void main(String[] args) {
ListOfNumbers list = new ListOfNumbers();
list.writeList();
}
}当您运行此程序时，可能会发生两种可能性：
-
try块中发生异常
-
try块正常执行
创建新的FileWriter时可能会发生异常。 如果无法创建或写入指定的文件，则抛出IOException。
当发生异常时，我们将获得以下输出。
进入try语句 IOException => OutputFile.txt PrintWriter无法打开
当未发生异常且该try块正常执行时，我们将获得以下输出。
进入try语句 关闭PrintWriter
将创建一个OutputFile.txt，并包含以下内容
Value at: 0 = 0 Value at: 1 = 1 Value at: 2 = 2 Value at: 3 = 3 Value at: 4 = 4 Value at: 5 = 5 Value at: 6 = 6 Value at: 7 = 7 Value at: 8 = 8 Value at: 9 = 9
try ... catch...finally 详细流程
让我们尝试在上述示例的帮助下详细了解异常处理的流程。
上图描述了在创建新FileWriter时发生异常时的程序执行流程。
为了找到发生异常的方法，主方法调用writeList()方法，该方法随后调用FileWriter()方法来创建一个新的OutputFile.txt文件。
发生异常时，运行时系统将跳过try块中的其余代码。
它开始以相反的顺序搜索调用堆栈，以找到合适的异常处理程序。
这里，FileWriter没有异常处理程序，因此运行时系统检查调用堆栈中的下一个方法，即writeList。
writeList方法有两个异常处理程序：一个处理IndexOutOfBoundsException，另一个处理IOException。
然后，系统依次处理这些处理程序。
此示例中的第一个处理程序处理IndexOutOfBoundsException。 这与try块引发的IOException不匹配。
因此，检查下一个处理程序是哪个IOException处理程序。如与引发的异常类型匹配，因此将执行对应catch块中的代码。
执行异常处理程序后，将执行finally块。
在此场景中，由于FileWriter中发生了异常，所以PrintWriter对象out从未打开，因此不需要关闭。
现在，让我们假设在运行该程序时没有发生异常，并且try块正常执行。 在这种情况下，将创建并写入一个OutputFile.txt。
众所周知，finally块的执行与异常处理无关。由于没有异常发生，因此PrintWriter打开了并且需要关闭。这是通过finally块中的out.close()语句完成的。
捕获和处理多个异常
在Java 7之前，即使存在代码冗余，我们也必须针对不同类型的异常编写多个异常处理代码。
示例1：多个捕获块
class Main {
public static void main(String[] args) {
try {
int array[] = new int[10];
array[10] = 30 / 0;
} catch (ArithmeticException e) {
System.out.println(e.getMessage());
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
}输出结果
/ by zero在此的示例可能会发生两个异常：
ArithmeticException - 因为我们试图将数字除以0。
ArrayIndexOutOfBoundsException - 因为我们已经声明了一个新的整数数组，数组边界为0到9，并且我们试图为索引10分配一个值。
我们在两个catch块中都打印出异常消息，即重复代码。
赋值运算符（=）的关联性是从右到左，因此首先将ArithmeticException与消息 / by zero起抛出。
在catch块中处理多个异常
现在可以在单个catch块中捕获多种类型的异常。
可以由catch块处理的每种异常类型都使用竖线（|）分隔。
其语法为：
try {
// code
} catch (ExceptionType1 | Exceptiontype2 ex) {
// catch block
}示例2：单个catch块中捕获多个异常
class Main {
public static void main(String[] args) {
try {
int array[] = new int[10];
array[10] = 30 / 0;
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
}输出结果
/ by zero在单个catch块中捕获多个异常，可以减少代码重复并提高效率。
编译该程序时生成的字节码将比具有多个catch块的程序小，因为没有代码冗余。
注意：如果一个catch块处理多个异常，则catch参数为隐式final。这意味着我们不能分配任何值来捕获参数。
捕获基本异常
当在单个catch块中捕获多个异常时，该规则将泛化为专门化规则。
这意味着，如果catch块中存在异常的层次结构，我们只能捕获基本异常，而不能捕获多个专门的异常。
让我们举个实例。
示例3：仅捕获基本异常类
class Main {
public static void main(String[] args) {
try {
int array[] = new int[10];
array[10] = 30 / 0;
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}输出结果
/ by zero我们知道所有异常类都是Exception类的子类。因此，我们不必捕获多个专门的异常，而只需捕获Exception类。
如果已经在catch块中指定了基本异常类，则不要在同catch一块中使用子异常类。否则，我们会得到一个编译错误。
让我们举个实例。
示例4：捕获基类和子异常类
class Main {
public static void main(String[] args) {
try {
int array[] = new int[10];
array[10] = 30 / 0;
} catch (Exception | ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
}输出结果
Main.java:6: error: Alternatives in a multi-catch statement cannot be related by subclassing在此示例中，ArithmeticException和ArrayIndexOutOfBoundsException都是Exception类的子类。 因此，我们抛出一个编译错误。
