Java异常被抛出或被捕获之后，代码是否继续执行的问题

在写程序的时候，我们经常被教导，要对异常的信息进行处理，哪里该抛出异常。但是，更多的时候，我们只是模仿异常的抛出，却不知道为什么要这样抛异常（被catch了？被向上抛了？后面的代码是否执行了？）。

接下来，我就简单的说一下异常抛出后的代码执行问题。此处不讨论自定义异常，因为自定义异常有自己的处理方式。

一、结论：

1. 凡是有异常的地方，需要有处理异常的地方。（示例：Demo1, Demo2）
2. 只要异常被处理，异常处理之后的代码都可以正常执行。（示例：Demo1, Demo2）
3. 异常被往上抛出，则抛出异常之后的代码将不被执行。（示例：Demo2, Demo3）

二、示例代码

接下来用两段代码来说明异常抛出后代码执行的顺序

示例1.

Demo1.java

/**
 * 抛出异常的代码是放在 try 中
 */
public class Demo1 {
    public static void main(String[] args) {
        try {
            print();
            Thread.sleep(200);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("打印抛出异常");
        }
        System.out.println("程序结束");
    }

    private static void print() {
        int index = 0;
        while (index < 15) {
            try {
                Thread.sleep(200);
                ++index;
                if (index == 5 || index == 10) {
                    throw new Exception();
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("循环抛出异常");
            }
            System.out.println("index = " + index);
        }
        System.out.println("循环结束");
    }
}

运行结果：

index = 1
index = 2
index = 3
index = 4
java.lang.Exception
循环抛出异常
index = 5
    at com.example.demo.Demo1.print(Demo1.java:22)
    at com.example.demo.Demo1.main(Demo1.java:6)
index = 6
index = 7
index = 8
index = 9
java.lang.Exception
    at com.example.demo.Demo1.print(Demo1.java:22)
    at com.example.demo.Demo1.main(Demo1.java:6)
循环抛出异常
index = 10
index = 11
index = 12
index = 13
index = 14
index = 15
循环结束
程序结束

示例2.

Demo2.java

/**
 * 抛出异常的代码是放在 try 外
 */
public class Demo2 {
    public static void main(String[] args) {
        try {
            print();
            Thread.sleep(200);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("打印抛出异常");
        }
        System.out.println("程序结束");
    }

    private static void print() throws Exception{
        int index = 0;
        while (index < 15){
            if (index == 5 || index == 10){
                throw new Exception();
            }
            try {
                Thread.sleep(200);
                ++index;
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("循环抛出异常");
            }
            System.out.println("index = "+index);
        }
        System.out.println("循环结束");
    }
}

运行结果

index = 1
index = 2
index = 3
index = 4
index = 5
java.lang.Exception
    at com.example.demo.Demo2.print(Demo2.java:19)
    at com.example.demo.Demo2.main(Demo2.java:6)
打印抛出异常
程序结束

示例3.

Demo3.java

/**
 * 不对异常进行捕获，只是往上抛
 */
public class Demo3 {
    public static void main(String[] args) throws Exception {
        print();
        System.out.println("程序结束");
    }

    private static void print() throws Exception {
        int index = 0;
        while (index < 15){
            ++index;
            if (index == 5 || index == 10){
                throw new Exception();
            }
            System.out.println("index = "+index);
        }
        System.out.println("循环结束");
    }
}

运行结果

index = 1
index = 2
index = 3
index = 4
Exception in thread "main" java.lang.Exception
    at com.example.demo.Demo3.print(Demo3.java:15)
    at com.example.demo.Demo3.main(Demo3.java:5)

三、分析

Demo1 与 Demo2 的区别在于抛出异常的代码是放在 try 中，还是放在 try 外。

//抛出异常的代码
if (index == 5 || index == 10){
    throw new Exception();
}

分析：Demo1

1. print 方法没有往 main 方法抛出异常，而是在循环中直接 catch 异常。
2. 异常被 catch 之后，循环继续执行。
3. 在 print 方法执行结束之后，因为 main 方法没有出现任何异常，print 方法之后的代码都能正常执行。

分析：Demo2

1. print 方法往 main 方法抛出异常。
2. 循环在异常出现的时候，循环将不再执行，异常被抛出到 main 方法中。
3. main 方法 catch 异常，异常在 catch 被处理之后，catch 之后的代码都能正常执行。

分析：Demo3

1. print 方法往 main 方法抛出异常。循环在异常出现的时候，循环将不再执行，异常被抛出到 main 方法中。
2. main 方法往上继续抛出异常。在 print 出现异常的时候，print 之后的代码将不再执行。

总结

1. 若一段代码前有异常抛出，并且这个异常没有被捕获，这段代码将产生编译时错误「无法访问的语句」。如代码1
2. 若一段代码前有异常抛出，并且这个异常被try…catch所捕获，如代码2，则有两种情况： 
   • 若该代码在try中抛出异常位置之后，则不执行；
   • 若在整个try-catch之后，且catch语句中没有抛出新的异常，则这段代码能够被执行，否则，同第1条。
3. 若在一个条件语句中抛出异常，则程序能被编译，但后面的语句不会被执行。如代码3

运行时异常与非运行时异常

• 运行时异常是RuntimeException类及其子类的异常，是非受检异常，如NullPointerException、IndexOutOfBoundsException等。由于这类异常要么是系统异常，无法处理，如网络问题； 
  要么是程序逻辑错误，如空指针异常；JVM必须停止运行以改正这种错误，所以运行时异常可以不进行处理（捕获或向上抛出，当然也可以处理），而由JVM自行处理。Java Runtime会自动catch到程序throw的RuntimeException，然后停止线程，打印异常。
• 非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类，是受检异常。非运行时异常必须进行处理（捕获或向上抛出），如果不处理，程序将出现编译错误。一般情况下，API中写了throws的Exception都不是RuntimeException。

常见运行时异常 

常见非运行时异常