非常详细讲解Java中try, catch and finally相关解析以及它们与return的执行顺序

转自：https://blog.csdn.net/S_gy_Zetrov/article/details/68490882、

Java中关于try…catch…finally异常处理的细节辨析

什么时候执行finally; finally后面的语句执行吗; try…catch…finally块中的finally语句是不是一定会被执行; Java中finally与return的执行顺序详解;

首先需要明确几点：

try语句块中的代码应是可能出现异常的代码，可能会抛出一个或多个异常，因此，try后面可跟一个或多个catch
如果异常间关系不大，则catch的顺序可以随意。但如果异常间有父类子类继承关系，则必须将子类异常catch放置在父类异常catch前面，以防止一场直接被父类catch接住，没有输出我们想要的具体子类异常信息
如果try中没有出现异常，则catch不被执行。但不管catch接没接住，try有没有异常，只要有finally，则都会执行finally（general情况，其他情况详见后）。
finally后面的语句是否执行与try或catch中有无return有关
这篇博客耗的时间比较长，我仔细验证了几个猜测。现在记录下来。

整篇文章较长，阅读大约需要8min

finally后面的语句什么时候执行？

还是先看一个例子：

public class TestFinally {
    public static void main(String[] args){
        try{
            return;
        }
        finally{
            System.out.println("Finally");
        }
    }
}

输出:

Finally

可以看出：当try中无异常发生，finally仍执行

如果去除return更换为其它普通语句

public class TestFinally {
    public static void main(String[] args){
        try{
            int a=3;
            a+=5;
            System.out.println(a);
        }
        finally{
            System.out.println("Finally");
        }
        int b=5;
        b+=5;
        System.out.println(b);
    }
}

输出:

Finally

可以看出：finally后面语句正常执行

如果try中加入return，不能编译，提示

int b=5;
b+=5;
System.out.println(b);

这部分代码是unreachable code
得证如果try中有return，则finally后面的代码不会执行(for ‘catch’ is the same thing)

附上一些证明栗子，可以跳过
例1

public class TestFinally {
    public static void a() throws Exception{
        try{
            throw new Exception();
        }
        catch(Exception e){
            System.out.println("exception000");
        }
        finally{
            System.out.println("finally111");
        }
    }
    public static void main(String[] args){
        try{
            a();
        }
        catch(Exception e){
            System.out.println("exception");
        }
        System.out.println("finished");
    }
}

输出:

exception000
finally111
finished

异常在方法中被接住，main中catch不会执行，catch后的代码正常执行

删去exception000项后

public class TestFinally {
    public static void a() throws Exception{
        try{
            throw new Exception();
        }
        /catch(Exception e){
            System.out.println("exception000");
        }/
        finally{
            System.out.println("finally111");
        }
    }
    public static void main(String[] args){
        try{
            a();
        }
        catch(Exception e){
            System.out.println("exception");
        }
        System.out.println("finished");
    }
}

输出：

finally111
exception
finished

异常方法中没被接住，但在main中被接住，catch后代码正常执行

删去finally111项后

package trycatchfinally;

public class TestFinally {
    public static void a() throws Exception{
        try{
            throw new Exception();
        }
        catch(Exception e){
            System.out.println("exception000");
        }
        /finally{
            System.out.println("finally111");
        }/
    }
    public static void main(String[] args){
        try{
            a();
        }
        catch(Exception e){
            System.out.println("exception");
        }
        System.out.println("finished");
    }
}

输出：

exception000
finished

finally被注释，故不执行，异常被方法中的catch接住，main中catch后代码正常执行

例2

public class TestFinally {
    public static String output="";
    public static void a(int i){
        try{
            if(i==1){
                throw new Exception();
            }
            output+="1";
        }
        catch(Exception e){
            output+="2";
            return;
        }
        finally{output+="3";}
        output+="4";
    }
    public static void main(String[] args){
        a(0);
        a(1);
        System.out.println(TestFinally.output);
    }
}

输出：

可以看出，catch中有return，则finally后面的代码不会执行

去掉return后

package trycatchfinally;

public class TestFinally {
    public static String output="";
    public static void a(int i){
        try{
            if(i==1){
                throw new Exception();
            }
            output+="1";
        }
        catch(Exception e){
            output+="2";
            //return;
        }
        finally{output+="3";}
        output+="4";
    }
    public static void main(String[] args){
        a(0);
        a(1);
        System.out.println(TestFinally.output);
    }
}

输出：

finally后代码执行，得证。

什么时候finally执行？什么时候不执行？

经过搜索，找到一位前辈的博客，她写到至少两种情况下finally是出现但不执行的

try语句没有被执行到，如在try语句之前就返回了，这样finally语句就不会执行，这也说明了finally语句被执行的必要而非充分条件是：相应的try语句一定被执行到。
在try块中有System.exit(0);这样的语句，System.exit(0);是终止Java虚拟机JVM的，连JVM都停止了，所有都结束了，当然finally语句也不会被执行到。
接下来的内容就比较深入细节了，没有这方面了解的需求可直接略过

现在我们已经知道finally后面的语句执行与try/catch中有无return有关，但finally块本身执行是在return的前面还是后面还是什么时候？
一个我比较认同的结论：

finally块的语句在try或catch中的return语句执行之后返回之前执行且finally里的修改语句可能影响也可能不影响try或catch中 return已经确定的返回值，若finally里也有return语句则覆盖try或catch中的return语句直接返回

要想明白这个问题，需要一些背景知识：

java方法是在栈帧中执行，栈帧是线程私有栈的单位，执行方法的线程会为每一个方法分配一小块栈空间来作为该方法执行时的内存空间，栈帧分为三个区域：

操作数栈，用来保存正在执行的表达式中的操作数，数据结构中学习过基于栈的多项式求值算法，操作数栈的作用和这个一样
局部变量区，用来保存方法中使用的变量，包括方法参数，方法内部声明的变量，以及方法中使用到的对象的成员变量或类的成员变量（静态变量），最后两种变量会复制到局部变量区，因此在多线程环境下，这种变量需要根据需要声明为volatile类型
字节码指令区，这个不用解释了，就是方法中的代码翻译成的指令
return语句：
return语句的格式如下：
return [expression]；
其中expression(表达式)是可选的，因为有些方法没有返回值，所以return后面也就没有表达式，或者可以看做是空的表达式。
我们知道return语句的作用可以结束方法并返回一个值，那么他返回的是哪里的值呢？返回的是return指令执行的时刻，操作数栈顶的值，不管expression是一个怎样的表达式，究竟做了些什么工作，对于return指令来说都不重要，他只负责把操作数栈顶的值返回。

而return expression是分成两部分执行的:

执行：expression；

执行：return指令；

例如：return x+y；

这句代码先执行x+y，再执行return；首先执行将x以及y从局部变量区复制到操作数栈顶的指令，然后执行加法指令，这个时候结果x+y的值会保存在操作数栈的栈顶，最后执行return指令，返回操作数栈顶的值。

对于return x；先执行x，x也是一个表达式，这个表达式只有一个操作数，会执行将变量x从局部变量区复制到操作数栈顶的指令，然后执行return，返回操作数栈顶的值。

因此return x实际返回的是return指令执行时，x在操作数栈顶的一个快照或者叫副本，而不是x这个值。

finally语句在return语句执行之后还是之前执行？
栗子1：

public class TestFinally {
    public static void main(String[] args) {        
        System.out.println(test1());
    }
    public static int test1() {
        int b = 20;
        try {
            System.out.println("try");
            return b += 80; 
        }
        catch (Exception e) {
            System.out.println("catch");
        }
        finally {           
            System.out.println("finally");          
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
        }       
        return b;
    }  
}

输出：

try
finally
b>25, b = 100
100

说明return语句已经执行了再去执行finally语句，不过并没有直接返回，而是等finally语句执行完了再返回结果。即：finally语句在return语句执行之后return返回之前执行的。
再来一个栗子2：

public class TestFinally {
        public static void main(String[] args) {            
            System.out.println(test11());
        }       
        public static String test11() {
            try {
                System.out.println("try");
                return test12();
          } finally {
               System.out.println("finally");
           }
      }
      public static String test12() {
           System.out.println("return statement");
           return "after return";
       }
}

输出：

try
return statement
finally
after return

如果finally里也有return语句，那么是不是就直接返回了，try中的return就不能返回了？

public class TestFinally {
        public static void main(String[] args) {
            System.out.println(test2());
        }
        public static int test2() {
            int b = 20;
            try {
                System.out.println("try");
                return b += 80;
            } catch (Exception e) {
                System.out.println("catch");
            } finally {
                System.out.println("finally");
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
                return 200;
            }
            // return b;
        }
}

输出：

try
finally
b>25, b = 100
200

说明finally里的return直接返回了，就不管try中是否还有返回语句，这里还有个小细节需要注意，finally里加上return过后，finally外面的return b就变成不可到达语句了，也就是永远不能被执行到，所以需要注释掉否则编译器报错。即finally块中的return语句会覆盖try块中的return返回。

如果finally中没有return，会如何返回？

try{
    return expression;
}finally{
    do some work;
}

首先我们知道，finally语句是一定会执行，但他们的执行顺序是怎么样的呢？他们的执行顺序如下：

1.执行：expression，计算该表达式，结果保存在操作数栈顶；
2.执行：操作数栈顶值（expression的结果）复制到局部变量区作为返回值；
3.执行：finally语句块中的代码；
4.执行：将第2步复制到局部变量区的返回值又复制回操作数栈顶；
5.执行：return指令，返回操作数栈顶的值；

我们可以看到，在第一步执行完毕后，整个方法的返回值就已经确定了，由于还要执行finally代码块，因此程序会将返回值暂存在局部变量区，腾出操作数栈用来执行finally语句块中代码，等finally执行完毕，再将暂存的返回值又复制回操作数栈顶。所以无论finally语句块中执行了什么操作，都无法影响返回值，所以试图在finally语句块中修改返回值是徒劳的。因此，finally语句块设计出来的目的只是为了让方法执行一些重要的收尾工作，而不是用来计算返回值的。

但我前面刚说finally里的return直接返回了，就不管try中是否还有返回语句，都不管try直接返回了，这是不是矛盾呢？

并不是。仔细阅读刚才的代码，可以看到，执行return后面的表达式，但值并没有立即返回，会转去执行finally，然后再返回刚才没有返回的值。如果finally里面返回了一个常值如return 200，这时才会直接返回，不管之前要返回的值。

如果finally里没有return语句，但修改了b的值，那么try中return返回的是修改后的值还是原值？

public class TestFinally {
    public static void main(String[] args) {
        System.out.println(test3());
    }
    public static int test3() {
        int b = 20;
        try {
            System.out.println("try");              
            return b += 80;
        } catch (Exception e) {
            System.out.println("catch");
        } finally {
            System.out.println("finally");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            b = 150;
        }
        return 2000;
    }
}

输出：

try
finally
b>25, b = 100
100

如果return使用在基本数据变量上，则finally中对改基本数据变量的修改不会生效！如果作用的是对象如Integer包装类或者其他正常对象如`Map
每次返回的一定是try中的return语句？那么finally后面的return语句（如果有）永远不会执行？
try块里的return语句在异常的情况下不会被执行，这样具体返回哪个看情况

public class TestFinally {
    public static void main(String[] args) {
        System.out.println(test4());
    }
    public static int test4() {
        int b = 20;
        try {
                System.out.println("try");
                b = b / 0;
                return b += 80;
            } catch (Exception e) {
                b += 15;
                System.out.println("catch");
            } finally {
                System.out.println("finally");
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
               }
               b += 50;
            }
            return 26;
      }
}

输出：

try
catch
finally
b>25, b = 35
26

这里因为在return之前发生了除0异常，所以try中的return不会被执行到，而是接着执行捕获异常的catch 语句和最终的finally语句，此时两者对b的修改都影响了最终的返回值，这时return b;就起到作用了。当然如果将return b改为return 300什么的，最后返回的就是300。

如果catch中有return，则执行情况与未发生异常时try中return的执行情况完全一样。

public class TestFinally {
    public static void main(String[] args) {
            System.out.println(test5());
        }
        public static int test5() {
            int b = 20;
            try {
                System.out.println("try");             
                b = b /0;
                return b += 80;
            } catch (Exception e) {
                System.out.println("catch");
                return b += 15;
            } finally {
                System.out.println("finally");
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
                b += 50;
            }
            //return b;
            //Unreachable code
        }
}

输出：

try
catch
finally
b>25, b = 35
35

说明了发生异常后，catch中的return语句先执行，确定了返回值后再去执行finally块，执行完了catch再返回，finally里对b的改变对返回值无影响，原因同前面一样，也就是说情况与try中的return语句执行完全一样。

如果想输出85，需要这么改，即finally中return，覆盖catch中的try。

public class TestFinally {
    public static void main(String[] args) {
            System.out.println(test5());
        }
        public static int test5() {
            int b = 20;
            try {
                System.out.println("try block");               
                b = b /0;
                return b += 80;
            } catch (Exception e) {
                System.out.println("catch block");
                return b += 15;
            } finally {
                System.out.println("finally block");
                if (b > 25) {
                    System.out.println("b>25, b = " + b);
                }
                b += 50;
                return b;
            }
            //return b;
        }
}

输出：

try block
catch block
finally block
b>25, b = 35
85

至此，此篇结束。关于这块的问题相信我已经明白了二三事，希望看到这的你也有收获 :)

参考文献：
1：http://www.cnblogs.com/lanxuezaipiao/p/3440471.html
2：http://blog.csdn.net/qj19842011/article/details/45675057

最后编辑于：2018.12.09 23:27:21

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 211,948评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,371评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 157,490评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,521评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,627评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,842评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,997评论 3赞 408
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,741评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,203评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,534评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,673评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,339评论 4赞 330
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,955评论 3赞 313
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,770评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,000评论 1赞 266
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,394评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,562评论 2赞 349

非常详细讲解Java中try, catch and finally相关解析以及它们与return的执行顺序

Java中关于try…catch…finally异常处理的细节辨析

finally后面的语句什么时候执行？

什么时候finally执行？什么时候不执行？

推荐阅读更多精彩内容