时光荏苒，转眼间毕业都半年了，java编程也五个月了。写代码的过程中，会经常遇到解决代码抛异常的情况。平时只注重完成功能，也没太注意try_catch_finally的内在执行顺序，只知道表面的现象：try里的代码运行出错，catch抓着异常处理，finally最后总要执行。知道一次遇到个少见的问题，当着项目经理的面，把我给难住了，才发现自己会最表面的东西，稍一深入，就跪了。于是痛定思痛，决定做个彻底的爱学的青年。
 
 
  闲话到此。下面切入正题。
 
 
1.普通情况（当然，也是最常见的情况）
 
 
我们定义了一个方法，里面有try_catch_finally代码块。
 
 
 
  
public void methodA() throws Exception{
   try{
      int i=9,j=0;
      int num= i/j;
      System.out.println("---- run------");
   }catch(Exception e){
      System.out.println("----catch run------");
   }finally{
     System.out.println("----finally run------");
   }
}
 
 
 
 
我们会看到，程序运行结果：  ----catch run------ ----finally run------
 
 
这是最常见的，最普通的情况。
 
 
2.特殊情况A
 
 
 
  
public static int method2_A() throws Exception{
   try{
      return -1;
      System.out.println("---- run------");
   }catch(Exception e){
      System.out.println("----catch run------");
   }finally{
     System.out.println("----finally run------");
   }
}
public static void main(String[] args) throws Exception{
  System.out.println(method2_A());
}
 
 
 
 
运行结果：----finally run---  -1
 
 
相信很多朋友到这就会有疑问了：咦，怎么是这种顺序呢？return后不久直接跳出函数了吗？finally怎么也这行了？是的，就是这种顺序。jdk底层是怎么执行字节码文件的，咱不去讨论。我在网上找了很多资料，最有权威的说法：jdk执行到try里的return语句时，会暂时把需要return的值放到一个临时的内存区域，然后执行finally里的代码，finally执行完后，jdk在回到临时存储区域把值return。
 
 
3.特殊情况B
 
 
 
  
public static int method3_B() throws Exception{
   try{
      return -1;
      System.out.println("---- run------");
   }catch(Exception e){
      System.out.println("----catch run------");
   }finally{
     System.out.println("----finally run------");
    return -2;
   }
}
public static void main(String[] args) throws Exception{
  System.out.println(method3_B());
}
 
 
 
 
运行结果：----finally run---  -2。这次不但try里有return，finally里也有return了，情况和2又不一样了。jdk走到try的return后，把值临时放到临时存储区，然后执行finally代码，（注意）当读到finally里的return后，直接就把这个值return了，不在回到try里存储的临时区域。
 
 
4.特殊情况C(catch里有return,finally里没有return)
 
 
 
  
public static int method4_C() throws Exception{
   try{
     int i=9,j=0;
    int num= i/j;
      return -1;
      System.out.println("---- run------");
   }catch(Exception e){
      System.out.println("----catch run------");
     return -2;
   }finally{
     System.out.println("----finally run------");
   }
}
public static void main(String[] args) throws Exception{
  System.out.println(method4_C());
}
 
 
 
 
运行结果：---catch run---   ----finally run---  -2。原理和上面类似，jdk执行字节码，遇到代码有异常，到catch里，有return语句，先不return，执行finally。然后回到catch里return语句临时存储区域，把值return。
 
 
5.特殊情况D(catch里有return,finally里有return)
 
 
 
  
public static int method5_D() throws Exception{
   try{ int i=9,j=0; int num= i/j; return -1; System.out.println("---- run------"); }catch(Exception e){ System.out.println("----catch run------"); return -2; }finally{ System.out.println("----finally run------");
 return -3; } } public static void main(String[] args) throws Exception{ System.out.println(method5_D()); }
 
 
 
 
运行结果：---catch run---   ----finally run---  -3。原理和上面类似，jdk执行字节码，遇到代码有异常，到catch里，有return语句，先不return，把值存储到临时存储区。执行finally,有return,直接return值，不在回到catch的临时存储区。
 
 
暂时就总结到这，以后有需要在完善。
 
 
 
 
 
转载于:https://www.cnblogs.com/westward/p/5034511.html

结论：
 
不管有没有出现异常，finally代码块都会执行；
不管try和catch的代码块中有return时，finally仍会执行，且如果finally代码块也有return，则此代码肯定会返回finally执行的return值。
 
分有return和没有return来讨论try-catch-finally执行顺序的情况：
 
1 无return
 
举个例子：
 
try {
    t();
    tt();
} catch (Exception e) {
    c();
} finally {
    f();
}
m();
 
1.1 当try中的t()没有抛出异常
 
因为没有捕捉到异常，那么执行try而不会执行catch，而finally无论如何都要执行。
 其执行顺序为：t() --> tt() --> f() --> m()
 
1.2 当try中的t()抛出了异常
 
当 t() 中抛出异常，那么 t() 中从抛出异常的语句之后的代码以及 tt() 都不会执行， 程序会尝试捕捉异常。
 捕捉Exception，捕捉成功，执行 c() ；
 一旦捕捉到一个异常，不会再尝试捕捉其他异常，直接执行finally里的f();
 执行后面的函数 m() 。
 其执行顺序为：t() --> c() --> f() --> m()
 
2 有return
 
2.1
 
try{}
catch(){}
finally{}
return;
 
程序按顺序执行
 
2.2 try块中有return
 
try{return 1;}
catch(){}
finally{}
return 2;
 
程序执行try块中return之前（包括return语句中的表达式运算）代码；
 再执行finally块，最后执行try中return;
 finally块之后的语句return不再执行，因为程序在try中已经return过了。
 结论：得到try中的返回值1。
 
2.3 catch块中有return
 
try{}
catch(){return 1;}
finally{}
return 2;
 
程序先执行try，如果遇到异常执行catch块，
 
有异常：执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，最后执行catch块中return。 finally之后的return不再执行。
无异常：执行完try再finally再return。
 结论：有异常影响catch，执行catch中的return得到返回值1。
 
2.4 try块和finally块中有return
 
try{return 1;}
catch(){}
finally{return 2;}
 
无异常：程序执行try块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出，而不再执行try中的return；
有异常：不执行try，顺序执行catch-finally
 结论：得到finally中的返回值2。
 
2.5 catch块和finally块中有return
 
try{}
catch(){return 1;}
finally{return 2;}
 
无异常：执行try后跳过catch执行finally；得到finally的返回值2；
有异常：程序执行catch块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出。而不再执行catch中的return。
 结论：得到finally中的返回值2。
 
2.6 try块、catch块和finally块中有return
 
try{return 1;}
catch(){return 2;}
finally{return 3;}
 
程序执行try块中return之前（包括return语句中的表达式运算）代码；
 
无异常：然后再执行finally块，因为finally块中有return所以提前退出。
有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出。
 结论：得到finally中的返回值3。
 
3 总结
 
无return，无异常
 
try ->finally
 
无return，有异常
 
try(未出现异常的前半段) -> catch ->finally
 
try或catch中有return，无异常
 
try -> finally ->return(try)
 
try或catch中有return，有异常
 
try(未出现异常的前半段) -> catch ->finally->return(catch)
 
只要是finally中有return的情况
 不论有没有异常,try或catch中有没有return
 
try/catch->return(finally)
 
我们可以看出当finally中有return的时候，相当于此代码肯定会返回该值。
 
4. 补充
 
public class ExceptionTest {
    int age;
    public static void main(String[] args) {
        System.out.println(test().age);
    }
    public static ExceptionTest test() {
        ExceptionTest test = new ExceptionTest();
        try {
            test.age = 10;
            return test;
        }catch (Exception e) {
            test.age = 20;
            return test;
        }finally {
            test = new ExceptionTest();
            test.age = 30;
        }
    }
}

 
输出：10
 当 try-catch 块中有return 语句时，return 语句会暂存变量值，然后执行 finally 代码块。

引言
 
关于try catch finally 执行顺序的笔试面试题目非常的多，我曾经在牛客网刷题的时候不止一次的碰到过，而且不止一次的做错过，这里面需要涉及的细节如果不弄清楚每次做题就会产生似是而非的感觉。这次查阅了很多相关资料，关于try catch finally 执行顺序各方面基本都讲到了。不足之处欢迎指出。
 
try catch finally 执行顺序
 
仅仅在下面4中情况下不会执行finally语句 :
 
①.如果在try 或catch语句中执行了System.exit(0)。
 
②.在执行finally之前jvm崩溃了。
 
③.try语句中执行死循环。
 
④.电源断电。
 
 
除了以上的四种情况外，finally语句都会执行，finally语句执行时会有以下原则。
 
①、不管有没有出现异常，finally块中代码都会执行；
 
  public void demo1(){
        try {

          System.out.println(result);

        } catch (Exception e) {                     
            System.out.println(e.getMessage());
        }
         finally {            
                System.out.println("finally trumps. ");
            }
//输出结果为：
result
finally trumps .
 
上面代码可知如果未出现异常是顺序执行try和finally代码块。
 
②、当try和catch中有return时，finally仍然会执行；
 
public static int demo2() {
        try {
            return 0;
        }
        finally {
            System.out.println("finally trumps return.");
        }
    }
//输出结果

finally trumps return.
0   
 
当finally里面没有return语句是，执行try 和finally语句之后最后再执行return。 
 ③、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
 
public static int demo3()
    {
         int i = 0;
            try {
                i = 2;
                return i;
            } finally {
                i = 12;
                System.out.println("finally trumps return.");
            }       
    }
//输出结果
    finally trumps return.
    2
 
此处中finally中对i赋值12但是demo3的返回值仍然是2，也就是在finally中对i赋值并未改变i的返回值，这里需要详细的讲一下，此处涉及到了jvm机制。先给出上面代码的字节码然后给出图解：
 
public static demo3()I
    TRYCATCHBLOCK L0 L1 L2 
   L3
    LINENUMBER 12 L3
    ICONST_0
    ISTORE 0
   L0
    LINENUMBER 14 L0
    ICONST_2
    ISTORE 0
   L4
    LINENUMBER 15 L4
    ILOAD 0
    ISTORE 2
   L1
    LINENUMBER 17 L1
    BIPUSH 12
    ISTORE 0
   L5
    LINENUMBER 18 L5
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "finally trumps return."
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
   L6
    LINENUMBER 15 L6
    ILOAD 2
    IRETURN
   L2
    LINENUMBER 16 L2
   FRAME FULL [I] [java/lang/Throwable]
    ASTORE 1
   L7
    LINENUMBER 17 L7
    BIPUSH 12
    ISTORE 0
   L8
    LINENUMBER 18 L8
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "finally trumps return."
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
   L9
    LINENUMBER 19 L9
    ALOAD 1
    ATHROW
 
上面的字节码比较长，下面简要的讲一下，其实我在http://blog.csdn.net/u013309870/article/details/72935274这篇文章中详细的讲过方法中代码的执行过程， 
  
 在variable内存中有两个变量区域一个是用来存放i的值，对应最上面的那个，另一个用于存放返回值。在上面代码执行到i = 2; return i;先对i赋值2，然后执行return语句此时并不是将结果返回，而是将i=2的值保存到返回值变量区域，在执行完i=12时，再返回variable中返回值地址变量区域的2。
 
④、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
 
    public static int demo4() {
        int i = 0;
        try {
            return i;
        } finally {
            i = 12;
            System.out.println("finally trumps return.");
            return i;
        }
    }
    //输出结果
    finally trumps return.
    12  
 
上面为什么会返回12呢？因为在程序还未执行try中的return语句时就先执行了finally里面的return语句所以返回结果为12。
 
经典面试题
 
下面题目输出什么？
 

    public static int demo5() {
        try {
            return printX();
        }
        finally {
            System.out.println("finally trumps return... sort of");
        }
    }
    public static int printX() {

        System.out.println("X");
        return 0;
    }
 
输出结果：
 
X
finally trumps return... sort of
0
 
上面这道题目含金量很高，程序顺序执行时先执行printX（）函数，此时得到返回值0并且将0保存到variable中对应的用于保存返回值的区域，此时程序在执行finally语句因为finally语句中没有return语句，所以程序将返回值区域的0返回给上一级函数。
 
参考文献
 
https://stackoverflow.com/questions/65035/does-finally-always-execute-in-java 
 http://blog.csdn.net/u013309870/article/details/72935274 
 深入理解Java虚拟机（高清第二版）JVM高级特性与最佳实践