Java异常处理的3种常用方式（附带实例）

我们知道，Java 程序中可以用 try-catch-finally 语句块进行异常处理，但是如果一段代码块中处理的异常类型较多时，我们又该以什么样的形式进行处理呢？

下面，我们先来看一段代码，这段代码有两处可能抛出异常：

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int result = 0;
        int number1 = 0;
        int number2 = 0;
        // 这里可能会抛出异常
        System.out.print("number1=");
        number1 = scanner.nextInt();
        System.out.print("number2=");
        number2 = scanner.nextInt();
        // 这里也可能抛出异常
        result = number1 / number2;
        System.out.println(result);
    }
}

程序中可能会抛出异常的地方有两个，那么我们应该如何处理呢？

Java分开捕获异常

分开捕获就是在可能出现不同异常的地方，分开依次进行捕获处理，这样做的好处就是我们可以非常清晰地知道哪些地方进行了什么异常处理，结构清晰。

接下来，通过案例来演示分开捕获的使用：

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int result = 0;
        int number1 = 0;
        int number2 = 0;
        // 这里可能会抛出异常
        try {
            System.out.print("number1=");
            number1 = scanner.nextInt();
            System.out.print("number2=");
            number2 = scanner.nextInt();
        } catch (InputMismatchException e) {
            e.printStackTrace();
        }
        // 这里也可能抛出异常
        try {
            result = number1 / number2;
            System.out.println(result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
}

程序中，将可能会抛出异常的两个地方分别使用 try-catch 语句块进行捕获，这种方式可以解决这两个可能会出现的异常问题。

Java嵌套捕获异常

嵌套捕获就是在异常捕获处理语句块中对于可能出现异常的部分再次进行异常捕获处理。

异常处理流程代码可以放在任何能放可执行性代码的地方，因此完整的异常处理流程可放在 try-catch-finally 语句块中的任意位置。异常处理嵌套的深度没有明确的限制，但通常没有必要使用超过两层的嵌套异常处理，层次太深的嵌套异常处理没有太大必要，而且会导致程序可读性降低。

接下来，通过案例来演示嵌套捕获的使用：

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int result = 0;
        int number1 = 0;
        int number2 = 0;
        // 这里可能会抛出异常
        try {
            System.out.print("number1=");
            number1 = scanner.nextInt();
            System.out.print("number2=");
            number2 = scanner.nextInt();
        }
        // 这里也可能抛出异常
        try {
            result = number1 / number2;
            System.out.println(result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } catch (InputMismatchException e) {
            e.printStackTrace();
        }
    }
}

程序中，将可能会抛出异常的两个地方通过嵌套的方式使用 try-catch 进行捕获，这种方式也可以解决这两个可能会出现的异常问题。

Java联动捕获异常

在前面两个实例中，我们对两个可能会出现异常的位置做了不同的处理，虽然都可以解决这两个异常问题，但是会发现不管用哪种方式都会写两遍 try-catch 语句块，甚至第 2 种方式还会影响代码的可读性。

为了解决这种问题，Java 提供了另外一种异常捕获处理方式——联动捕获。

所谓联动捕获，具体指的是一个 try 语句块配合多个 catch 语句块，当异常发生以后，符合异常情况的 catch 语句块就会被执行，其他的 catch 语句块会被跳过。

接下来，通过案例来演示联动捕获的使用：

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int result = 0;
        int number1 = 0;
        int number2 = 0;
        // 这里可能会抛出异常
        try {
            System.out.print("number1=");
            number1 = scanner.nextInt();
            System.out.print("number2=");
            number2 = scanner.nextInt();
        }
        // 这里也可能抛出异常
        try {
            result = number1 / number2;
            System.out.println(result);
        } catch (InputMismatchException e) {
            e.printStackTrace();
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
}

程序中，将可能会抛出异常的两个地方用 try 语句块包住，使用两个 catch 语句块进行捕获不同的异常，这种方式可以有效地解决前面实例中这两种方式造成的麻烦，并且也能解决可能会出现的异常。

注意，使用联动捕获时，下边的 catch 语句块捕获的异常类必须是上边 catch 语句块的同级类或是父级类。