第4节 异常处理

异常处理学习的目标：

1. 明确说明是异常（重点）

2. 能辨识出常见的异常及其含义（熟悉）

3. 理解异常产生的原理（了解）

4. 能处理异常（重点）

5. 能够自定义异常（熟悉）

一、什么是异常？

异常是在程序中导致程序中断运行的一种指令流 。

例如，现在有如下的操作代码：

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的处理流程

1. 一旦产生异常，则系统会自动产生一个异常类的实例化对象；

2. 那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出；

3. 所有的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("输入有误");}}
}

多异常捕获的注意点：

1. 捕获更粗的异常不能放在捕获更细的异常之前；

2. 如果为了方便，则可以将所有异常都使用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) {//退出JVMSystem.out.println("出现了异常");System.exit(0);}finally {System.out.println("锄禾日当午");}}
}

结果如下：

出现了异常

没有执行finally里的代码，就结束了。

三、异常体系结构

异常指的是Exception类在Java中存在一个父类Throwable（可能的抛出）。

Throwable存在两个子类：

1. Error：表示的是错误，是JVM发出的错误操作，只能尽量避免，无法用代码处理；

2. Exception：一般表示所有程序中的错误，所以一般在程序中进行try-catch的处理。

可以看一下JDK API中文手册里的Exception里的子类：

其中需要特别注意的是RuntimeException类，它是非受检异常，也叫运行时异常，它只有在程序运行时才能知道是否会发生，事先无法检查出来，看一下它的子类：

   比如数学运算异常、数组索引超出范围异常等等，在代码编写时编译器是不能察觉的，只有运行时的确发生异常了才会出现。所以异常也可以细分为两类：

1. 受检异常：

2. 非受检异常/运行时异常：

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);