你真的了解try catch finally 吗？

迷南。 2021-12-22 03:11 261阅读 0赞

# 结论： #

1.  不管有没有出现异常，finally块中代码都会执行；
2.  当try和catch中有return时，finally仍然会执行；
3.  finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；（仅限于基础数据类型和string 不适用于引用类型（比如一个User对象））
4.  finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

# 举例： #

**情况1：** try\{\} catch()\{\}finally\{\} return;  
显然程序按顺序执行。  
**情况2:** try\{ return; \}catch()\{\} finally\{\} return;  
程序执行try块中return之前（包括return语句中的表达式运算）代码；  
再执行finally块，最后执行try中return;  
finally块之后的语句return，因为程序在try中已经return所以不再执行。  
**情况3:** try\{ \} catch()\{return;\} finally\{\} return;  
程序先执行try，如果遇到异常执行catch块，  
有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，  
最后执行catch块中return. finally之后也就是4处的代码不再执行。  
无异常：执行完try再finally再return.  
**情况4:** try\{ return; \}catch()\{\} finally\{return;\}  
程序执行try块中return之前（包括return语句中的表达式运算）代码；  
再执行finally块，因为finally块中有return所以提前退出。  
**情况5:** try\{\} catch()\{return;\}finally\{return;\}  
程序执行catch块中return之前（包括return语句中的表达式运算）代码；  
再执行finally块，因为finally块中有return所以提前退出。  
**情况6:** try\{ return;\}catch()\{return;\} finally\{return;\}  
程序执行try块中return之前（包括return语句中的表达式运算）代码；  
有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；  
则再执行finally块，因为finally块中有return所以提前退出。  
无异常：则再执行finally块，因为finally块中有return所以提前退出。

# 最终结论： #

任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。  
如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，  
编译器把finally中的return实现为一个warning。

下面是个测试程序

public class FinallyTest { 
        public static void main(String[] args) { 
            System.out.println(test());
        }
    
        static int test() { 
            int x = 1;
            try { 
                x++;
                return x;
            } finally { 
                --x;
            }
        }

结果是2。

在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。  
在转去之前，try中先把要返回的结果存放到不同于x的局部变量中去，执行完finally之后，在从中取出返回结果，  
因此，即使finally中对变量x进行了改变，但是不会影响返回结果。  
它应该使用栈保存返回值。

# 注意： #

如果没有异常出现，而且finally语句中没有return，则会执行try里边的return，并且，会将变量暂存起来(对象存的是引用的地址)，再去执行finally中的语句，这时候，如果返回值是基本数据类型或者字符串，则finally相当于更改副本，不会对暂存值有影响；但是，如果返回值是对象，则finally中的语句，仍会根据地址的副本，改变原对象的值。  
示例代码：

实体类：

public class User { 
    
        private String name;
        private  String age;
    
        public User() { 
        }
    
        public User(String name, String age) { 
            this.name = name;
            this.age = age;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public String getAge() { 
            return age;
        }
    
        public void setAge(String age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "name='" + name + '\'' +
                    ", age='" + age + '\'' +
                    '}';
        }
    }

测试代码：

public class TestTry { 
    
        public static void main(String[] args) { 
            User user = new User("zs", "18");
            User user1 = test2(user);
            System.out.println(user1);
        }
        public static User test2(User user) { 
            try { 
                user.setAge("99");
                return user;
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                user.setAge("88");
            }
            user.setAge("66");
            return user;
        }
    }

运行截图：我在25行打了一个断点，实际上并没有走到这一步，因为在try中已经进行了return。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70]

# 使用try catch 的规范 #

**使用try-catch-finally时，必须遵循以下几条规则：**

①必须在 try 之后添加 catch 或 finally 块，try 块后可同时接 catch 和 finally 块，但至少有一个块。

② 若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。

③ catch 块与相应的异常类的类型相关。

④ 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块。

⑤ 可嵌套 try-catch-finally 结构。

⑥在 try-catch-finally 结构中，可重新抛出异常。

⑦除了下列情况，总将执行 finally 做为结束：JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70]: /images/20211220/dae09786915a4d52b6bae97ea70c7e6d.png