Java 的异常处理

什么是程序的异常

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的。

比如客户输入数据的格式问题，读取文件是否存在，网络是否始终保持通畅等等。

异常指的是程序在执行过程中出现的非正常情况，如果不处理最终会导致 JVM 的非正常停止。

异常指的并不是语法错误和逻辑错误。语法错了，编译不通过，不会产生字节码文件，根本不能运行。代码逻辑错误，只是没有得到想要的结果，例如求 a 与 b 的和，你写成了 a-b。

异常的抛出机制

Java 中是如何表示不同的异常情况，又是如何让程序员得知，并处理异常的呢？

Java 中把不同的异常用不同的类表示，一旦发生某种异常，就创建该异常类型的对象，并且抛出（throw）。

然后程序员可以捕获（catch）到这个异常对象并处理。

如果没有捕获（catch）这个异常对象，那么这个异常对象将会导致程序终止。

举个例子，运行下面的程序，程序会产生一个数组角标越界异常 ArrayIndexOfBoundsException。

java

package javacode.exception;

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {34, 12, 67};
        int num = ArrayTools.getElement(arr, 4);
        System.out.println("num=" + num);
        System.out.println("over");
    }
}

class ArrayTools {
    // 对给定的数组通过给定的角标获取元素。
    public static int getElement(int[] arr, int index) {
        int element = arr[index];
        return element;
    }
}

如何对待异常

对于程序出现的异常，一般有两种解决方法。

一是遇到错误就终止程序的运行。

另一种方法是程序员在编写程序时，就充分考虑到各种可能发生的异常和错误并做出处理。

Throwable

java.lang.Throwable 类是 Java 程序执行过程中发生的异常事件对应的类的根父类。

Throwable 中的常用方法：

public void printStackTrace()：打印异常的详细信息。包含了异常的类型、异常的原因、异常出现的位置。在开发和调试阶段都推荐使用 printStackTrace
public String getMessage()：获取发生异常的原因

Error 和 Exception

Throwable 可分为两类：Error 和 Exception。分别对应着 java.lang.Error 与 java.lang.Exception 两个类。

Error 为 Java 虚拟机无法解决的严重问题。如 JVM 系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。例如 StackOverflowError（栈内存溢出）和 OutOfMemoryError（堆内存溢出，简称 OOM）。

Exception 为其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。例如：

空指针访问
读取不存在的文件
网络连接中断
数组角标越界

编译时异常和运行时异常

Java 程序的执行分为编译时过程和运行时过程。有的错误只有在运行时才会发生。比如除数为 0、数组下标越界。

因此，根据异常可能出现的阶段，可以将异常分为编译时期异常和运行时期异常。

编译时期异常（checked 异常、受检异常）：在代码编译阶段，编译器就能明确警示当前代码可能发生（不是一定发生）xx 异常，并要求程序员提前编写处理它的代码。如果程序员没有编写对应的异常处理代码，则编译器就会直接判定编译失败，从而不能生成字节码文件。通常这类异常的发生不是由程序员的代码引起的，或者不是靠加简单判断就可以避免的，例如 FileNotFoundException（文件找不到异常）
运行时期异常（runtime 异常、unchecked 异常、非受检异常）：在代码编译阶段，编译器没有检测到异常。代码运行起来并确实发生了 xx 异常，它才被编译器发现。通常运行时异常是由程序员的代码编写不当引起的

常见的错误和异常

Error

最常见的是 VirtualMachineError，它有两个经典的子类：StackOverflowError、OutOfMemoryError。

StackOverflowError：

java

package javacode.exception;

import org.junit.Test;

public class StackOverflowErrorClass {
    @Test
    public void test() {
        recursion();
    }

    public void recursion(){ //递归方法
        recursion();
    }
}

OutOfMemoryError：

java

package javacode.exception;

import org.junit.Test;

public class StackOverflowErrorClass {
    @Test
    public void test() {
        recursion();
    }

    public void recursion(){ //递归方法
        recursion();
    }
}

运行时异常

java

package javacode.exception;

import org.junit.Test;

import java.util.Scanner;

public class TestRuntimeException {
    @Test
    public void test() {
        // NullPointerException
        int[][] arr = new int[3][];
        System.out.println(arr[0].length);
    }

    @Test
    public void test2() {
        // ClassCastException
        Object obj = 15;
        String str = (String) obj;
    }

    @Test
    public void test3() {
        // ArrayIndexOutOfBoundsException
        int[] arr = new int[5];
        for (int i = 1; i <= 5; i++) {
            System.out.println(arr[i]);
        }
    }

    @Test
    public void test4() {
        // InputMismatchException
        Scanner input = new Scanner(System.in);
        System.out.print("请输入一个整数："); // 输入非整数
        int num = input.nextInt();
        input.close();
    }

    @Test
    public void test5() {
        int a = 1;
        int b = 0;
        // ArithmeticException
        System.out.println(a / b);
    }
}

编译时异常

java

package javacode.exception;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class TestCheckedException {
    @Test
    public void test() throws InterruptedException {
        // 如果该线程在休眠期间，其它线程中断了此线程，那么就可能抛出 InterruptedException 异常
        Thread.sleep(1000); // 休眠 1 秒 InterruptedException
    }
    @Test
    public void test2() throws ClassNotFoundException {
        // ClassNotFoundException
        // 什么情况下会出现该异常呢？
        // ClassNotFoundException – if the class cannot be located
        Class c = Class.forName("java.lang.String");
    }
    @Test
    public void test3() throws SQLException {
        // SQLException
        // SQLException – if a database access error occurs or the url is null
        Connection conn = DriverManager.getConnection("....");
    }
    @Test
    public void test4() throws FileNotFoundException {
        // FileNotFoundException
        // FileNotFoundException – if the file does not exist, is a directory rather than a regular file,
        // or for some other reason cannot be opened for reading
        FileInputStream fis = new FileInputStream("Java.txt");
    }
    @Test
    public void test5() throws IOException {
        File file = new File("Java.txt");
        FileInputStream fis = new FileInputStream(file); // FileNotFoundException
        int b = fis.read(); // IOException
        while(b != -1){
            System.out.print((char)b);
            b = fis.read(); // IOException
        }

        fis.close();// IOException
    }
}

异常的处理

Java 异常处理的方式有两种，一种是 try-catch-finally 形式，一种是 throws + 异常类型 形式。

捕获异常（try-catch-finally）

Java 提供了异常处理的抓抛模型。

Java 程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给 Java 运行时系统，这个过程称为抛出（throw）异常。

如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获（catch）异常。

如果一个异常回到 main() 方法，并且 main() 也不处理，则程序运行终止。

捕获异常语法如下：

try{
	......	// 可能产生异常的代码
}
catch( 异常类型 1 e ){
	......	// 当产生异常类型 1 型异常时的处置措施
}
catch( 异常类型 2 e ){
	...... 	// 当产生异常类型 2 型异常时的处置措施
}  
finally{
	...... // 无论是否发生异常，都无条件执行的语句
}

当某段代码可能发生异常，不管这个异常是编译时异常（受检异常）还是运行时异常（非受检异常），我们都可以使用 try 块将它括起来，并在 try 块下面编写 catch 分支尝试捕获对应的异常对象。

如果在程序运行时，try 块中的代码没有发生异常，那么 catch 所有的分支都不执行。

如果在程序运行时，try 块中的代码发生了异常，根据异常对象的类型，将从上到下选择第一个匹配的 catch 分支执行。此时 try 中发生异常的语句下面的代码将不执行，而整个 try...catch 之后的代码可以继续运行。

如果在程序运行时，try 块中的代码发生了异常，但是所有 catch 分支都无法匹配（捕获）这个异常，那么 JVM 将会终止当前方法的执行，并把异常对象“抛”给调用者。如果调用者不处理，程序就挂了。

捕获异常的第一步是用 try{...} 语句块选定捕获异常的范围，将可能出现异常的业务逻辑代码放在 try 语句块中。

catch 分支，分为两个部分，catch() 中编写异常类型和异常参数名，{} 中编写如果发生了这个异常，要做什么处理的代码。

如果明确知道产生的是何种异常，可以用该异常类作为 catch 的参数；也可以用其父类作为 catch 的参数。

比如，可以用 ArithmeticException 类作为参数的地方，就可以用 RuntimeException 类作为参数，或者用所有异常的父类 Exception 类作为参数。但不能是与 ArithmeticException 类无关的异常，如 NullPointerException（catch 中的语句将不会执行）。

每个 try 语句块可以伴随一个或多个 catch 语句，用于处理可能产生的不同类型的异常对象。

如果有多个 catch 分支，并且多个异常类型有父子类关系，必须保证小的子异常类型在上，大的父异常类型在下。否则报错。

catch 中常用异常处理的方式：

public String getMessage()：获取异常的描述信息，返回字符串
public void printStackTrace()：打印异常的跟踪栈信息并输出到控制台。包含了异常的类型、异常的原因、异常出现的位置

finally 使用及举例

因为异常会引发程序跳转，从而会导致有些语句执行不到。而程序中有一些特定的代码无论异常是否发生，都需要执行。例如数据库连接、输入流输出流、Socket 连接、Lock 锁的关闭等，这样的代码通常就会放到 finally 块中。所以，我们通常将一定要被执行的代码声明在 finally 中。

不论在 try 代码块中是否发生了异常事件，catch 语句是否执行，catch 语句是否有异常，catch 语句中是否有 return，finally 块中的语句都会被执行。

finally 语句和 catch 语句是可选的，但 finally 不能单独使用。

举例 1，确保资源关闭。

java

package javacode.exception;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TestFinally {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数：");
            int a = input.nextInt();
            System.out.print("请输入第二个整数：");
            int b = input.nextInt();
            int result = a / b;
            System.out.println(a + "/" + b + "=" + result);
        } catch (InputMismatchException e) {
            System.out.println("数字格式不正确，请输入两个整数");
        } catch (ArithmeticException e) {
            System.out.println("第二个整数不能为 0");
        } finally {
            System.out.println("程序结束，释放资源");
            input.close();
        }
    }

    @Test
    public void test1() {
        FileInputStream fis = null;
        try {
            File file = new File("hello1.txt");
            fis = new FileInputStream(file);// FileNotFoundException
            int b = fis.read(); // IOException
            while (b != -1) {
                System.out.print((char) b);
                b = fis.read(); // IOException
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null)
                    fis.close();// IOException
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

举例 2，try 中得到返回值。

java

package javacode.exception;

public class FinallyTest1 {
    public static void main(String[] args) {
        int result = test("12");
        System.out.println(result);
    }

    public static int test(String str){
        try{
            Integer.parseInt(str);
            return 1;
        }catch(NumberFormatException e){
            return -1;
        }finally{
            System.out.println("test 结束");
        }
    }
}

举例 3。

java

package javacode.exception;

public class Finally3 {
    public static void main(String[] args) {
        int result = test();
        // 因为不是引用数据类型，所以还是 100
        System.out.println(result); // 100

        NumTest numTest = test2();
        System.out.println("numTest.count: " + numTest.count); // 101
    }

    public static int test(){
        int i = 100;
        try {
            return i;
        } finally {
            i++;
            // 101
            System.out.println("finnal i " + i);
        }
    }

    public static NumTest test2() {
        NumTest numTest = new NumTest();
        try {
            return numTest;
        } finally {
            numTest.count ++;
        }
    }
}

class NumTest {
    int count = 100;
}

声明抛出异常类型（throws）

如果在编写方法体的代码时，某句代码可能发生某个编译时异常，不处理编译不通过，但是在当前方法体中可能不适合处理或无法给出合理的处理方式，则此方法可以显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

在方法声明中用 throws 语句可以声明抛出异常的列表，throws 后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

throws 基本格式

修饰符 返回值类型 方法名(参数) throws 异常类名 1, 异常类名 2...{   }

在 throws 后面可以写多个异常类型，用逗号隔开。

java

package javacode.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test2 {
    public void readFile(String file)  throws FileNotFoundException, IOException {
        // 读文件的操作可能产生 FileNotFoundException 或 IOException 类型的异常
        FileInputStream fis = new FileInputStream(file);
        //...
    }
}

throws 使用举例

针对编译时异常。

java

package javacode.exception;

public class TestThrowsCheckedException {
    public static void main(String[] args) {
        System.out.println("上课.....");
        try {
            afterClass();// 换到这里处理异常
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("准备提前上课");
        }
        System.out.println("上课.....");
    }

    public static void afterClass() throws InterruptedException {
        for(int i=10; i>=1; i--){
            Thread.sleep(1000); // 本来应该在这里处理异常
            System.out.println("距离上课还有：" + i + "分钟");
        }
    }
}

针对运行时异常。

java

package javacode.exception;

import java.util.InputMismatchException;
import java.util.Scanner;

public class TestThrowsRuntimeException {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数：");
            int a = input.nextInt();
            System.out.print("请输入第二个整数：");
            int b = input.nextInt();
            int result = divide(a, b);
            System.out.println(a + "/" + b + "=" + result);
        } catch (ArithmeticException | InputMismatchException e) {
            System.out.println("输入数据类型有误");
            e.printStackTrace();
        } finally {
            input.close();
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        return a / b;
    }
}

方法重写中 throws 的要求

方法重写时，对于方法签名是有严格要求的。

方法名必须相同
形参列表必须相同
返回值类型如果还基本谁类型或 void，那么必须相同。如果是引用数据类型，那么是其本身的类型或其子类
要求父类被重写方法在子类中是可见的
不能是 static，final 修饰的方法

此外，对于 throws 异常列表也有要求：

如果父类被重写方法的方法签名后面没有“throws 编译时异常类型”，那么重写方法时，方法签名后面也不能出现“throws 编译时异常类型”
如果父类被重写方法的方法签名后面有“throws 编译时异常类型”，那么重写方法时， throws 的编译时异常类型必须“小于等于”被重写方法 throws 的编译时异常类型（简单的说，子类的错误类型应该更多更全，而不是更少），或者不 throws 编译时异常
方法重写，对于“throws 运行时异常类型”没有要求

java

package javacode.exception;

import java.io.IOException;

public class OverrideTest {
}

class Father {
    public void method() throws Exception {
        System.out.println("Father.method");
    }
    public void method2() {

    }
}

class Son extends Father {
    @Override
    public void method() throws IOException, ClassCastException {
        System.out.println("Son.method");
    }

//    父类方法没有 throws，只能也不能有
//    @Override
//    public void method2() throws IOException {
//        super.method2();
//    }
}

两种异常处理方式的选择

如果程序代码中，涉及到资源的调用（流、数据库连接、网络连接等），则必须考虑使用 try-catch-finally 来处理
如果父类被重写的方法没有 throws 异常类型，则子类重写的方法中如果出现异常，只能考虑使用 try-catch-finally 进行处理，不能 throws

手动抛出异常对象 throw

Java 中异常对象的生成有两种方式。

一种是由虚拟机自动生成，程序运行过程中，虚拟机检测到程序发生了问题，那么针对当前代码，就会在后台自动创建一个对应异常类的实例对象并抛出。

另一种由开发人员手动创建 new 异常类型([实参列表])。如果创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样，但是一旦 throw 抛出，就会对程序运行产生影响了。

使用格式

throw new 异常类名(参数);

throw 语句抛出的异常对象，和 JVM 自动创建和抛出的异常对象一样。

如果是编译时异常类型的对象，同样需要使用 throws 或者 try...catch 处理，否则编译不通过。

如果是运行时异常类型的对象，编译器不提示。

可以抛出的异常必须是 Throwable 或其子类的实例。下面的语句在编译时将会产生语法错误：

throw new String("want to throw");

使用注意点

无论是编译时异常类型的对象，还是运行时异常类型的对象，如果没有被 try..catch 合理的处理，都会导致程序崩溃。

throw 语句会导致程序执行流程被改变，throw 语句是明确抛出一个异常对象，因此它下面的代码将不会执行。

如果当前方法没有 try...catch 处理这个异常对象，throw 语句就会代替 return 语句提前终止当前方法的执行，并返回一个异常对象给调用者。

自定义异常

为什么需要自定义异常类

Java 中不同的异常类，分别表示着某一种具体的异常情况。那么在开发中总是有些异常情况是核心类库中没有定义好的，此时我们需要根据自己业务的异常情况来定义异常类。例如年龄负数问题，考试成绩负数问题，某员工已在团队中等。

如何自定义异常类

要继承一个异常类型

如果要自定义一个编译时异常类型，那么继承 java.lang.Exception，

如果要自定义一个运行时异常类型，那么继承 java.lang.RuntimeException。

提供至少两个构造器

一个是无参构造，一个是（String message）构造器。

自定义异常需要提供 serialVersionUID

注意点

自定义的异常只能通过 throw 抛出
自定义异常最重要的是异常类的名字和 message 属性。当异常出现时，可以根据名字判断异常类型。比如：TeamException("成员已满，无法添加");、TeamException("该员工已是某团队成员");
自定义异常对象只能手动抛出。抛出后由 try..catch 处理，也可以 throws 给调用者处理

例子 1：

java

package javacode.exception;

public class MyExpTest {
    public void regist(int num) throws MyException {
        if (num < 0)
            throw new MyException("人数为负值，不合理", 3);
        else
            System.out.println("登记人数" + num);
    }
    public void manager() {
        try {
            regist(-100);
        } catch (MyException e) {
            System.out.print("登记失败，出错种类" + e.getId());
        }
        System.out.print("本次登记操作结束");
    }
    public static void main(String args[]) {
        MyExpTest t = new MyExpTest();
        t.manager();
    }
}

class MyException extends Exception {
    static final long serialVersionUID = 23423423435L;
    private int idnumber;

    public MyException(String message, int id) {
        super(message);
        this.idnumber = id;
    }

    public int getId() {
        return idnumber;
    }
}

例子 2：

java

package javacode.exception;

public class TestTriangle {
    public static void main(String[] args) {
        Triangle t = null;
        try {
            t = new Triangle(2,2,3);
            System.out.println("三角形创建成功：");
            System.out.println(t);
        } catch (NotTriangleException e) {
            System.err.println("三角形创建失败");
            e.printStackTrace();
        }

        try {
            if(t != null) {
                t.setA(1);
            }
            System.out.println("三角形边长修改成功");
        } catch (NotTriangleException e) {
            System.out.println("三角形边长修改失败");
            e.printStackTrace();
        }
    }
}

class Triangle {
    private double a;
    private double b;
    private double c;

    public Triangle(double a, double b, double c) throws NotTriangleException {
        if(a<=0 || b<=0 || c<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public double getA() {
        return a;
    }

    public void setA(double a) throws NotTriangleException{
        if(a<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.a = a;
    }

    public double getB() {
        return b;
    }

    public void setB(double b) throws NotTriangleException {
        if(b<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.b = b;
    }

    public double getC() {
        return c;
    }

    public void setC(double c) throws NotTriangleException {
        if(c<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.c = c;
    }

    @Override
    public String toString() {
        return "Triangle{" +
                "a=" + a +
                ", b=" + b +
                ", c=" + c +
                '}';
    }
}

// 自定义异常：
class NotTriangleException extends Exception{
    static final long serialVersionUID = 13465653435L;

    public NotTriangleException() {
    }

    public NotTriangleException(String message) {
        super(message);
    }
}

Java 的异常处理 ​

什么是程序的异常 ​

异常的抛出机制 ​

如何对待异常 ​

Throwable ​

Error 和 Exception ​

编译时异常和运行时异常 ​

常见的错误和异常 ​

Error ​

运行时异常 ​

编译时异常 ​

异常的处理 ​

捕获异常（try-catch-finally） ​

finally 使用及举例 ​

声明抛出异常类型（throws） ​

throws 基本格式 ​

throws 使用举例 ​

方法重写中 throws 的要求 ​

两种异常处理方式的选择 ​

手动抛出异常对象 throw ​

使用格式 ​

使用注意点 ​

自定义异常 ​

为什么需要自定义异常类 ​

如何自定义异常类 ​

注意点 ​

Java 的异常处理

什么是程序的异常

异常的抛出机制

如何对待异常

Throwable

Error 和 Exception

编译时异常和运行时异常

常见的错误和异常

Error

运行时异常

编译时异常

异常的处理

捕获异常（try-catch-finally）

finally 使用及举例

声明抛出异常类型（throws）

throws 基本格式

throws 使用举例

方法重写中 throws 的要求

两种异常处理方式的选择

手动抛出异常对象 throw

使用格式

使用注意点

自定义异常

为什么需要自定义异常类

如何自定义异常类

注意点