Java中的异常处理--Java学习（9）

Java中的异常

在程序设计中，进行异常处理是非常关键和重要的一部分。一个程序的异常处理框架的好坏直接影响到整个项目的代码质量以及后期维护成本和难度。

什么是异常

• 异常的英文单词是exception，字面翻译就是“意外、例外”的意思，也就是非正常情况。

事实上，异常本质上是程序上的错误，包括程序逻辑错误和系统错误。比如使用空的引用、数组下标越界、内存溢出错误等，这些都是意外的情况，背离我们程序本身的意图。错误在我们编写程序的过程中会经常发生，包括编译期间和运行期间的错误，在编译期间出现的错误有编译器帮助我们一起修正，然而运行期间的错误便不是编译器力所能及了，并且运行期间的错误往往是难以预料的。假若程序在运行期间出现了错误，如果置之不理，程序便会终止或直接导致系统崩溃，显然这不是我们希望看到的结果。因此，如何对运行期间出现的错误进行处理和补救呢？Java提供了异常机制来进行处理，通过异常机制来处理程序运行期间出现的错误。通过异常机制，我们可以更好地提升程序的健壮性。

异常分类

在Java中异常被当做对象来处理，根类是java.lang.Throwable类，在Java中定义了很多异常类（如OutOfMemoryError、NullPointerException、IndexOutOfBoundsException等），这些异常类分为两大类：Error和Exception。

Error是无法处理的异常，比如OutOfMemoryError，一般发生这种异常，JVM会选择终止程序。因此我们编写程序时不需要关心这类异常。

Exception，也就是我们经常见到的一些异常情况，比如NullPointerException、IndexOutOfBoundsException，这些异常是我们可以处理的异常。

Exception类的异常包括checked exception和unchecked exception（unchecked
exception也称运行时异常RuntimeException，当然这里的运行时异常并不是前面我所说的运行期间的异常，只是Java中用运行时异常这个术语来表示，Exception类的异常都是在运行期间发生的）。

unchecked exception（非检查异常），也称运行时异常（RuntimeException），比如常见的NullPointerException、IndexOutOfBoundsException。对于运行时异常，java编译器不要求必须进行异常捕获处理或者抛出声明，由程序员自行决定。

checked exception（检查异常），也称非运行时异常（运行时异常以外的异常就是非运行时异常），java编译器强制程序员必须进行捕获处理，比如常见的IOExeption和SQLException。对于非运行时异常如果不进行捕获或者抛出声明处理，编译都不会通过。

在Java中，异常类的结构层次图

在Java中，所有异常类的父类是Throwable类，Error类是error类型异常的父类，Exception类是exception类型异常的父类，RuntimeException类是所有运行时异常的父类，RuntimeException以外的并且继承Exception的类是非运行时异常。

典型的RuntimeException包括NullPointerException、IndexOutOfBoundsException、IllegalArgumentException等。

典型的非RuntimeException包括IOException、SQLException等。

捕获异常

在Java中，凡是可能抛出异常的语句，都可以用 try … catch 捕获。把可能发生异常的语句放在 try { … } 中，然后使用 catch 捕获对应的 Exception 及其子类。
多catch语句
可以使用多个 catch 语句，每个 catch 分别捕获对应的 Exception 及其子类。JVM在捕获到异常后，会从上到下匹配 catch 语句，匹配到某个 catch 后，执行 catch 代码块，然后不再 继续匹配。
多个 catch 语句只有一个能被执行。例如：

public static void main(String[] args) {
	try {
		process1();
		process2();
		process3();
	} catch (IOException e) {
		System.out.println(e);
	} catch (NumberFormatException e) {
		System.out.println(e);
	}
}

存在多个 catch 的时候， catch 的顺序非常重要：子类必须写在前面。例如：

public static void main(String[] args) {
	try {
		process1();
		process2();
		process3();
	} catch (IOException e) {
		System.out.println("IO error");
	} catch (UnsupportedEncodingException e) { // 永远捕获不到
		System.out.println("Bad encoding");
	}
}

对于上面的代码， UnsupportedEncodingException 异常是永远捕获不到的，因为它是IOException 的子类。当抛出 UnsupportedEncodingException 异常时，会被 catch(IOException e) { … } 捕获并执行。因此，正确的写法是把子类放到前面。

finally语句

Java的 try … catch 机制还提供了 finally 语句，finally 语句块保证有无错误都会执行。

public static void main(String[] args) {
	try {
		process1();
		process2();
		process3();
	} catch (UnsupportedEncodingException e) {
		System.out.println("Bad encoding");
	} catch (IOException e) {
		System.out.println("IO error");
	} finally {
		System.out.println("END");
	}
}

注意 finally 有几个特点：

1. finally 语句不是必须的，可写可不写；
2. finally 总是最后执行。

如果没有发生异常，就正常执行 try { … } 语句块，然后执行 finally 。如果发生了异常，就中断执行 try { … } 语句块，然后跳转执行匹配的 catch 语句块，最后执行 finally 。
可见， finally 是用来保证一些代码必须执行的。

抛出异常

当发生错误时，例如，用户输入了非法的字符，我们就可以抛出异常。
如何抛出异常？参考 Integer.parseInt() 方法，抛出异常分两步：

1. 创建某个 Exception 的实例；
2. 用 throw 语句抛出。

例子

void process2(String s) {
	if (s==null) {
		NullPointerException e = new NullPointerException();
		throw e;
	}
}

实际上，绝大部分抛出异常的代码都会合并写成一行：

void process2(String s) {
	if (s==null) {
		throw new NullPointerException();
	}
}

异常的传播

当某个方法抛出了异常时，如果当前方法没有捕获异常，异常就会被抛到上层调用方法，直到遇到某个 try … catch 被捕获为止：

public class Main {
	public static void main(String[] args) {
		try {
			process1();
		} catch (Exception e) {
			e.printStackTrace();
	}
}
	static void process1() {
		process2();
	}
	static void process2() {
		Integer.parseInt(null); // 会抛出NumberFormatException
	}
}

通过 printStackTrace() 可以打印出方法的调用栈，类似：

java.lang.NumberFormatException: null
	at java.base/java.lang.Integer.parseInt(Integer.java:614)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
	at Main.process2(Main.java:16)
	at Main.process1(Main.java:12)
	at Main.main(Main.java:5)

printStackTrace() 对于调试错误非常有用，上述信息表示： NumberFormatException 是在java.lang.Integer.parseInt 方法中被抛出的，从下往上看，调用层次依次是：

1. main() 调用 process1() ；
2. process1() 调用 process2() ；
3. process2() 调用 Integer.parseInt(String) ；
4. Integer.parseInt(String) 调用 Integer.parseInt(String, int) 。

继承中异常的注意事项

1. 子类覆盖父类方法时，如果父类的方法声明异常，子类只能声明父类异常或者该异常的子类，或者不声明越来越精细。
2. 当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集 越来越精细。
3. 当被覆盖的方法没有异常声明时，子类覆盖时无法声明异常的。

举例：父类存在这种情况，接口也有这种情况，
问题：接口中没有声明异常，而实现的子类覆盖方法时发生了异常，怎么办？
无法进行throws声明，只能catch的捕获。万一问题处理不了呢？catch中继续throw抛出，但是只能将异常转换成RuntimeException子类抛出。