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 之后的代碼將不再執行。

可參考：執行throw后 后面代碼還會執行嗎？

           java中異常拋出后代碼還會繼續執行嗎？