java中finally和return的执行顺序（对比Go语言中defer）

朴灿烈づ我的快乐病毒、 2023-07-02 04:23 16阅读 0赞

## Go语言中defer ##

说`finally`之前我们先说说Go语言中`defer`

> Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。

在Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后，RET指令执行前。具体如下图所示：  
![defer执行顺序][defer]  
这里先看一个例子：

package main
    
    import "fmt"
    
    func demo() int { 
    	i := 10
    	defer func() { 
    		i = 20
    	}()
    	return i
    }
    func main() { 
    	fmt.Println(demo()) // 10
    }

执行上面代码的时候相当于执行下面步骤：

1.  返回值 = i = 10
2.  执行`defer`中的函数：i = 20
3.  `return`返回值（此时的`i`为20，但是返回值是10）

假设对切片类型进行和上面类似的操作：

package main
    
    import "fmt"
    
    func demo() []string { 
    	var sli []string
    	sli = append(sli, "hello")
    	defer func() { 
    		sli = append(sli, "world")
    	}()
    	return sli
    }
    func main() { 
    	fmt.Println(demo()) // [hello]
    }

同样，相当于执行以下操作：

1.  返回值 = `[hello]`
2.  执行`defer`中的函数：`sli = [hello,world]`
3.  `return`返回值

这里注意，每次执行`append`之后返回的切片地址都不同

假如我们自定义类型，然后对指针进行操作：

package main
    
    import (
    	"fmt"
    )
    
    type PersonA struct { 
    	name string
    	age  int
    }
    
    func test() *PersonA { 
    	p := &PersonA{ "小明", 18}
    	defer func() { 
    		p.name = "小红"
    	}()
    	return p
    }
    func main() { 
    	fmt.Println(test()) // &{小红 18}
    }

可见，运行结果为defer修改之后的值，事实上还是执行了以下步骤：

1.  返回值 = `p`的地址
2.  执行`defer`中的函数： 修改`p`的地址对应`PersonA`结构体
3.  返回`p`的地址

这时候再打印p地址对应的对象，显然是我们已经修改过的对象。

## java中的finally ##

java中的`finally`和`return`结合之后执行的顺序和Go语音中的`defer`类似

class MyExceptionDemo { 
      public static void demo() { 
        throw new RuntimeException();
      }
    
      public static int test() { 
        int i = 10;
        try { 
          demo();
          return i;
        } catch (Exception e) { 
          i = 20;
          return i;
        } finally { 
          i = 30;
        }
      }
    
      public static void main(String[] args) { 
        System.out.println(test()); // 20
      }
    }

这里相当于：

1.  返回值 = i = 20
2.  执行`finally`语句：i = 30
3.  将返回值（20）返回

上面的是基本数据类型，如果是引用类型的话：

class ExceptionDemo { 
      public static void demo() { 
        throw new RuntimeException();
      }
    
      public static StringBuffer test() { 
        StringBuffer sb = new StringBuffer();
        try { 
          demo();
          return sb;
        } catch (final Exception e) { 
          sb.append("do catch ");
          return sb;
        } finally { 
          sb.append("do finally ");
        }
      }
    
      public static void main(final String[] args) { 
        System.out.println(test()); // do catch do finally
      }
    }

执行顺序：

1.  返回值 = `sb`的地址
2.  执行`finally`：修改`sb`对应地址的对象
3.  返回`sb`的地址

当`finally`中有`return`语句的时候，`finally`中语句会覆盖`try`里的语句

public static void main(String[] args) { 
        System.out.println(test2()); // finally
    }
    
    public static String test2() { 
        String str;
        try { 
            str = "try";
            return str;
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            return "finally";
        }
    }

## finally使用过程中需要注意的地方 ##

*  不会执行`finally`的两种情况：
    
    1.  在`try`语句之前有`return`语句
    2.  程序中有`System.exit();`语句
 *  根据上面的例子，如果`finally`和`catch`中都有`return`语句的话，在`catch`中`return`语句没有返回的时候，`finally`中的`return`语句已经返回了，所以`finally`中的`return`语句会覆盖`catch`中的`return`语句

> 参考文章：  
> https://www.liwenzhou.com/posts/Go/09\_function/  
> https://mp.weixin.qq.com/s/yrwYkEQuD1t1iWtOuWyZ6w

[defer]: https://img-blog.csdnimg.cn/20200125220713996.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpMzQ1NTI3NzkyNQ==,size_16,color_FFFFFF,t_70