JavaSE——异常处理（异常简介、try-catch-finally、throws、throw）
第4节 异常处理
异常处理学习的目标：
-
明确说明是异常（重点）
-
能辨识出常见的异常及其含义（熟悉）
-
理解异常产生的原理（了解）
-
能处理异常（重点）
-
能够自定义异常（熟悉）
一、什么是异常？
异常是在程序中导致程序中断运行的一种指令流 。
例如，现在有如下的操作代码：
public class ExceptionDemo01{
public static void main(String argsp[]){
int i = 10 ;
int j = 0 ;
System.out.println("============= 计算开始 =============") ;
int temp = i / j ; // 进行除法运算
System.out.println("temp = " + temp) ;
System.out.println("============= 计算结束 =============") ;
}
};
运行结果：
============= 计算开始 =============
Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionDemo01.main(ExceptionDemo01.java:6)
以上的代码在int temp = i / j ;位置处产生了异常，一旦产生异常之后，异常之后的语句将不再执行了，所以现在的程序并没有正确的执行完毕之后就退出了。
那么，为了保证程序出现异常之后仍然可以正确的执行完毕 ，所以要采用异常的处理机制。
二、处理异常
如果要想对异常进行处理，则必须采用标准的处理格式，处理格式语法如下：
try{
// 有可能发生异常的代码段
}catch(异常类型 对象名1) {
//异常的处理操作
}catch(异常类型 对象名2) {
//异常的处理操作
}...
finally{
//异常的统一出口
}
下面分别来详细的介绍：
2.1 try+catch的处理流程
-
一旦产生异常，则系统会自动产生一个异常类的实例化对象；
-
那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出；
-
所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。
下面这张图将过程解释的更加具体：
2.2 多异常捕获
一段代码块可能产生多种异常时，需要对多种异常进行捕获，一般多异常捕获有三种方式：
方式一：分开处理：
package com.kaikeba.objectoriented.exceptionHandling;
import java.util.InputMismatchException;
import java.util.Scanner;
/**
* 处理多异常的格式 1：
*/
public class Demo2 {
public static void main(String[] args) {
haha();
System.out.println("程序执行完毕，正常结束");
}
private static void haha() {
try {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数字：");
int x = input.nextInt();
System.out.println("请再输入一个数字：");
int y = input.nextInt();
System.out.println(x / y);
System.out.println("处理完毕");
}catch (ArithmeticException e) {
System.out.println("除数不能为0");
}catch (InputMismatchException e) {
System.out.println("必须是数字");
}
}
}
方式二：使用|运算符合并：
package com.kaikeba.objectoriented.exceptionHandling;
import java.util.InputMismatchException;
import java.util.Scanner;
/**
* 处理多异常的格式 2：了解
*/
public class Demo3 {
public static void main(String[] args) {
haha();
System.out.println("程序执行完毕，正常结束");
}
private static void haha() {
try {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数字：");
int x = input.nextInt();
System.out.println("请再输入一个数字：");
int y = input.nextInt();
System.out.println(x / y);
System.out.println("处理完毕");
}catch (ArithmeticException | InputMismatchException e) {
System.out.println("输入有误");
}
}
}
方式三：合并为父类异常：
package com.kaikeba.objectoriented.exceptionHandling;
import java.util.InputMismatchException;
import java.util.Scanner;
/**
* 处理多异常的格式 3：常用
*/
public class Demo4 {
public static void main(String[] args) {
haha();
System.out.println("程序执行完毕，正常结束");
}
private static void haha() {
try {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数字：");
int x = input.nextInt();
System.out.println("请再输入一个数字：");
int y = input.nextInt();
System.out.println(x / y);
System.out.println("处理完毕");
}catch (RuntimeException e) {//多态
System.out.println("输入有误");
}
}
}
多异常捕获的注意点：
-
捕获更粗的异常不能放在捕获更细的异常之前；
-
如果为了方便，则可以将所有异常都使用Exception进行捕获。
2.3 finally
在进行异常处理之后，在异常的处理格式中还有一个finally语句，此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码。除非软件关闭、电脑关机等强制方法。
观察如下代码：
package com.kaikeba.objectoriented.exceptionHandling;
public class Demo5 {
public static void main(String[] args) {
haha();
}
public static void haha() {
try {
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println("4");
return;
}catch (Exception e) {
}finally {
System.out.println("锄禾日当午");
}
}
}
结果如下：
1
2
3
4
锄禾日当午
即使加了return;还是会执行finally里的代码。可以这样理解，return在返回返回值的时候，将返回值进行了一个备份，并做了一些准备工作然后才返回，在这个过程中，finally就执行了 ，所以效果如上所述。
那么这里就涉及到一个常问的面试题 ，查看如下两段代码：
package com.kaikeba.objectoriented.exceptionHandling;
public class Demo6 {
public static void main(String[] args) {
Person p = haha();
System.out.println(p.age);
}
public static Person haha() {
Person p = new Person();
try {
p.age = 18;
return p;
}catch(Exception e){
return null;
}finally {
p.age = 28;
}
}
static class Person{
int age;
}
}
结果为：28
package com.kaikeba.objectoriented.exceptionHandling;
public class Demo7 {
public static void main(String[] args) {
int a = haha();
System.out.println(a);
}
public static int haha() {
int a = 10;
try {
return a;
}catch(Exception e){
return 0;
}finally {
a = 20;
}
}
static class Person{
int age;
}
}
结果为：10
解释：在return的时候，都是对返回的值或者对象进行了一个备份，在准备返回的过程中finally执行了，如果是引用数据类型，p里面保存的是地址，那么备份也备份了这个地址，finally对属性值修改后，通过地址依然可以访问到这个修改后的结果；但是如果是基本数据类型，a里面是值，return备份的是10这个值，finally虽然的确也修改了啊变为20，但是这个备份还是10 ，观察内存图可能更好理解一点：
补充： 唯一一种在代码中导致finally不执行的方法——System.exit(0);它的作用是正常退出程序，结束当前正在运行的java虚拟机。
package com.kaikeba.objectoriented.exceptionHandling;
public class Demo8 {
public static void main(String[] args) {
haha();
}
public static void haha() {
try{
int a = 10;
int b = 0;
System.out.println(a/b);
}catch(Exception e) {
//退出JVM
System.out.println("出现了异常");
System.exit(0);
}finally {
System.out.println("锄禾日当午");
}
}
}
结果如下：
出现了异常
没有执行finally里的代码，就结束了。
三、异常体系结构
异常指的是Exception类在Java中存在一个父类Throwable（可能的抛出）。
Throwable存在两个子类：
-
Error：表示的是错误，是JVM发出的错误操作，只能尽量避免，无法用代码处理； -
Exception：一般表示所有程序中的错误，所以一般在程序中进行try-catch的处理。
可以看一下JDK API中文手册里的Exception里的子类：
其中需要特别注意的是RuntimeException类，它是非受检异常，也叫运行时异常，它只有在程序运行时才能知道是否会发生，事先无法检查出来，看一下它的子类：
比如数学运算异常、数组索引超出范围异常等等，在代码编写时编译器是不能察觉的，只有运行时的确发生异常了才会出现。
所以异常也可以细分为两类：
-
受检异常：
-
非受检异常/运行时异常：
RuntimeException与Exception的区别
注意观察如下方法的源代码：
Integer类：public static int parseInt(String text throws NumberFormatException
此方法抛出了异常，但使用时却不需要进行try...catch捕获处理，原因：
因为 NumberFormatException 并不是Exception的直接子类，而是RuntimeException的直接子类，只要是RuntimeException的子类，则表示程序在操作的时候可以不必使用try-catch进行处理，如果有异常发生，则由JVM进行处理。当然，也可以通过try catch处理。
四、throws关键字
在程序中异常的基本处理已经掌握了，但是随异常一起的还有一个称为throws关键字，此关键字主要在方法的声明上使用，表示方法中不处理异常，而交给调用处处理。
格式：
返回值 方法名称() throws Exception{
}
package com.kaikeba.objectoriented.exceptionHandling;
import java.io.IOException;
public class Demo9 {
public static void main(String[] args) throws IOException {
shutdown("");
}
public static void shutdown(String text) throws IOException {
Runtime.getRuntime().exec(text);
}
public static void sum(String s1, String s2) {
try {
int sum = Integer.parseInt(s1) + Integer.parseInt(s2);
System.out.println("和是：" + sum);
}catch(NumberFormatException e) {
}
}
}
异常是应该抛出去还是处理，应该站在哪个角度进行思考：
如果是因为传参导致的异常，应该通过throws将异常抛出去 。
五、throw关键字
throw关键字表示在程序中人为的抛出一个异常 ，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。
看下面这个例子：
package com.kaikeba.objectoriented.exceptionHandling;
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age<0 || age>180) {
RuntimeException e = new RuntimeException("年龄不合理");
throw e;
}else {
this.age = age;
}
}
}
package com.kaikeba.objectoriented.exceptionHandling;
public class Demo10 {
public static void main(String[] args) {
Person p = new Person();
p.setAge(-1);
}
}
结果如下：
Exception in thread "main" java.lang.RuntimeException: 年龄不合理
at com.kaikeba.objectoriented.exceptionHandling.Person.setAge(Person.java:21)
at com.kaikeba.objectoriented.exceptionHandling.Demo10.main(Demo10.java:8)
Process finished with exit code 1
因为年龄如果输入不合理，我们就应该告诉执行者年龄有问题，不能像之前一样只是给它赋一个默认值，但是这里又没有任何异常的代码出现，所以为了逻辑上合理，将不合逻辑的年龄手动的抛出异常。
六、自定义异常类（了解）
-
编写一个类，继承
Exception，并重写一参构造方法 即可完成自定义受检异常类型。 -
编写一个类，继承
RuntimeExcepion，并重写一参构造方法 即可完成自定义运行时异常类型。
例如：
class MyException extends Exception{
public MyException(String msg){ //继承Exception，表示一个自定义异常类
super(msg); //调用Exception中有一个参数的构造
}
}
自定义异常可以做很多事情， 例如：
class MyException extends Exception{
public MyException(String msg){
super(msg) ;
//在这里给维护人员发短信或邮件， 告知程序出现了BUG。
}
}
上述throw抛出异常的例子可以结合自定义类，就是将`RuntimeException`改为自定义的异常类，代码如下：
package com.kaikeba.objectoriented.exceptionHandling.MyExpection;
public class AgeRuntimeException extends RuntimeException{
{
//给程序员发短信
}
public AgeRuntimeException(String message) {
super(message);
}
}
package com.kaikeba.objectoriented.exceptionHandling.MyExpection;
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age<0 || age>180) {
AgeRuntimeException e = new AgeRuntimeException("年龄不合理");
throw e;
}else {
this.age = age;
}
}
}
package com.kaikeba.objectoriented.exceptionHandling.MyExpection;
public class Demo {
public static void main(String[] args) {
Person p = new Person();
p.setAge(-1);
}
}
结果如下：
Exception in thread "main" com.kaikeba.objectoriented.exceptionHandling.MyExpection.AgeRuntimeException: 年龄不合理
at com.kaikeba.objectoriented.exceptionHandling.MyExpection.Person.setAge(Person.java:21)
at com.kaikeba.objectoriented.exceptionHandling.MyExpection.Demo.main(Demo.java:6)
Process finished with exit code 1
七、异常处理常见面试题
1. try-catch-finally中哪个部分可以省略？
答：catch和finally可以省略其中一个，catch和finally不能同时省略。
注意：格式上允许省略catch块，但是发生异常时就不会捕获异常了，在开发中也不会这样去写代码。
2. try-catch-finally中，如果catch中return了，finally还会执行吗？
答：finally中的代码会执行。
详解：
执行流程：
1. 先计算返回值，并将返回值存储起来，等待返回；
2. 执行finally代码块；
3. 将之前存储的返回值，返回出去。
需注意：
1. 返回值是在finally运算之前就确定了，并且缓存了，
不管finally对该值做任何的改变，返回的值都不会改变；
2. finally代码中不建议包含return，
因为程序会在上述的流程中提前退出，也就是说返回的值不是try或catch中的值；
3. 如果在try或catch中停止了JVM，则finally不会执行，例如停电，或通过如下代码退出：
JVM：System.exit(0);