Java异常捕获机制：return与finally的执行顺序解析

当返回终于遇到时

我已经在网上看到了许多关于Java中最终的诉讼机制中最终语句的讨论。

首先，让我们清楚地表明，以下两种情况最终未执行：

1）。返回语句是在尝试之前返回的，当然不会执行它。

2）。 System.EXIT（0）在TRY语句中使用以强制从JVM退出，当然，将不会执行Brute Force退出。

让我们先看以下代码

package com.loongshaw;
public class TryReturnFinally {
     public static void main(String[] args) {
         System.out.println(test1());        
     }
     public static int test1() {
         int b = 1;
         try {           
             System.out.println("try block");           
             return ++b;             
         }
         catch (Exception e) {           
             b = 10;
             System.out.println("catch block");
         }
         finally {              
             ++b;
             System.out.println("finally block");
         }       
         System.out.println("last block");
         return b;
     }
}

如果您认为执行结果是3，请继续观看。你很受欢迎，哈哈。

让我们首先看一下执行结果：

try block
finally block
2

可以看出，以上代码的执行结果为2。常规想法最终被执行，并在尝试中。它显然被执行了两个++ BS，发生了什么？

目前，让我们打破重点并看看：

（1）。当程序在尝试中执行返回语句时，b仍然为1。

（2）。然后，当程序执行最终语句时，执行++ b，而b变为2。

（3）。目前，我们在尝试中单击b…返回并发现其值变为2。

上面的结果说明了一件事：执行返回语句，然后执行最终语句，但是返回语句不会直接返回，而是在执行最终语句后返回。

通过以下测试案例提高理解：

package com.loongshaw;
public class TryReturnFinally {
     public static void main(String[] args) {
         System.out.println(test2());
     }
     public static String test2() {
         try {
             System.out.println("try block");           
             return test3();             
         }
         catch (Exception e) {
             System.out.println("catch block");
         }
         finally {
             System.out.println("finally block");
         }
         System.out.println("last block");
         return "last block";
     }
     public static String test3() {                      
         System.out.println("return block");
         return "output return block";
     }
}

执行结果：

try block
return block
finally block
output return block

从上面的结果中，我们可以发现，在执行try语句中的返回时，执行其test3（）方法，将其返回值保存在临时变量中，然后最后执行语句。

 try {           
       System.out.println("try block");         
       return test3();           
    }

最后，输出存储在临时变量返回值中。

output return block

也许每个人都会继续说，如果终于有回报并捕捉到的情况，那是什么情况：

（1）首先看渔获量的回报

 public static int test4() {
         int b = 1;
         try {
             System.out.println("try block");           
             return b/0; 
         }
         catch (Exception e) {
             System.out.println("catch block");
             return ++b;
         }
         finally {
             b = b+ 10;
             System.out.println("finally block");
         }
     }

结果

try block
catch block
finally block
2

可以看出，捕获中的回报与尝试并将最终执行，但不会影响尝试和捕获的返回结果。

（2）然后看到终于有回报

public static int test5() {
         int b = 1;
         try {
             System.out.println("try block");           
             return ++b; 
         }
         catch (Exception e) {
             ++b;
             System.out.println("catch block");
             return b;
         }
         finally {
             b = b+ 10;
             System.out.println("finally block");
             return b;
         }
     }

结果

try block
finally block
12

可以看出，回报最终直接返回，这与尝试和捕获的回报不同。

您可能会发现Test1（）方法的最终返回未执行，对吗？

public static int test1() {  
    ...    
    System.out.println("last block");
    return b;
    ...
}

通常，除非触发捕获量，否则它将不会执行。这是修改的摘要代码：

 public static int test1() {
         int b = 1;
         try {
             b = b/0;
             System.out.println("try block");           
             return ++b; 
         }
         catch (Exception e) {
             b = 10;
             System.out.println("catch block");
         }
         finally {
             b = b+ 10;
             System.out.println("finally block");
         }
         System.out.println("last block");
         return b;
     }

执行结果：

 catch block
finally block
last block
20

从上面的结果可以得出结论，当触发时，将执行最外面的返回。

总结：

在尝试返回之后和之前捕获语句，执行了最终语句；如果最终语句中没有返回，则执行结果不会影响尝试和捕获中确定的返回值；如果在最后的语句中有返回，将执行执行该结果将直接返回。