一、基本规则
无论try块中是否发生异常，finally代码块总会执行 （唯一例外：程序调用System.exit()强制终止 JVM）。
但当try/catch块中存在return语句时，二者的执行顺序会呈现特殊逻辑，这也是面试的核心考察点。
二、不同场景下的执行顺序分析
通过实战代码示例，逐一拆解不同场景下finally与return的执行逻辑。
场景 1：try 中有 return，finally 中无 return
java
public class FinallyDemo {
public static int test1() {
try {
System.out.println("try block");
return 1;
} finally {
System.out.println("finally block");
}
}
public static void main(String[] args) {
System.out.println(test1());
}
}执行结果：
text
try block
finally block
1执行顺序拆解：
- 执行
try块代码，遇到return语句； - 计算
return表达式的值（本例中1被暂存到临时变量）； - 执行
finally代码块（核心：finally在return返回前执行）； - 返回之前暂存的
return值（1）。
场景 2：try 和 finally 中都有 return
java
public class FinallyDemo {
public static int test2() {
try {
System.out.println("try block");
return 1;
} finally {
System.out.println("finally block");
return 2; // finally中的return会覆盖try中的return
}
}
public static void main(String[] args) {
System.out.println(test2()); // 输出 2
}
}核心结论 ：finally中的return会直接覆盖 try（或catch）中的return值，最终返回finally的return结果。
场景 3：try 中 return 的是引用类型
java
public class FinallyDemo {
public static StringBuilder test3() {
StringBuilder sb = new StringBuilder("hello");
try {
sb.append(" world");
return sb;
} finally {
sb.append(" from finally"); // 修改对象内容
System.out.println("finally: " + sb);
}
}
public static void main(String[] args) {
System.out.println("result: " + test3());
}
}执行结果：
text
finally: hello world from finally
result: hello world from finally关键说明：
- 基本类型：
return时暂存的是具体值 ，finally修改基本类型不会影响返回值； - 引用类型：
return时暂存的是对象的内存地址 ，finally中修改对象的内容，会直接影响最终返回的对象。
场景 4：try 中有异常，catch 和 finally 都有 return
java
public class FinallyDemo {
public static int test4() {
try {
System.out.println("try block");
int i = 1 / 0; // 抛出算术异常
return 1;
} catch (Exception e) {
System.out.println("catch block");
return 2;
} finally {
System.out.println("finally block");
return 3; // 覆盖catch中的return
}
}
public static void main(String[] args) {
System.out.println(test4()); // 输出 3
}
}三、特殊情况：finally 中的 return "吞掉" 异常
当try块抛出异常，但finally块中有return时，异常会被直接 "吞掉"，程序不会向外抛出异常 ------ 这是极其危险的写法！
java
public class FinallyDemo {
public static int test5() {
try {
System.out.println("try block");
int i = 1 / 0; // 抛出ArithmeticException
return 1;
} finally {
System.out.println("finally block");
return 2; // 异常被"吞掉"，无异常抛出
}
}
public static void main(String[] args) {
System.out.println(test5()); // 正常输出2，无异常
}
}⚠️ 警告：这种写法会隐藏程序中的异常，导致问题排查困难，实际开发中务必禁止！
四、执行顺序总结表
为方便记忆，整理不同场景下的执行结果：
| 场景 | try 有 return | catch 有 return | finally 有 return | 最终返回值 | 是否执行 finally |
|---|---|---|---|---|---|
| 1 | ✅ | ❌ | ❌ | try 的 return 值 | ✅ |
| 2 | ✅ | ❌ | ✅ | finally 的 return 值 | ✅ |
| 3 | ❌ | ✅ | ❌ | catch 的 return 值 | ✅ |
| 4 | ❌ | ✅ | ✅ | finally 的 return 值 | ✅ |
| 5 | ✅ | ✅ | ❌ | 无异常：try 的 return；有异常：catch 的 return | ✅ |
| 6 | 抛出异常 | ❌ | ✅ | finally 的 return 值 | ✅ |
五、最佳实践建议
finally的设计初衷是资源清理（如关闭文件、数据库连接、释放锁等），而非控制程序返回逻辑，以下是规范写法：
错误写法（禁止）
java
public int badPractice() {
try {
// 业务逻辑
return 1;
} finally {
// 错误：finally中使用return
return 2;
}
}正确写法 1：传统资源清理
java
import java.io.FileInputStream;
import java.io.IOException;
public class ResourceCleanupDemo {
public void readFile() {
FileInputStream fis = null;
try {
fis = new FileInputStream("file.txt");
// 处理文件内容
} catch (IOException e) {
e.printStackTrace();
} finally {
// finally仅用于关闭资源
if (fis != null) {
try {
fis.close(); // 关闭文件流
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}正确写法 2：Java 7+ try-with-resources（推荐）
Java 7 引入的try-with-resources语法，可自动关闭实现AutoCloseable接口的资源，无需手动在finally中关闭，代码更简洁：
java
import java.io.FileInputStream;
import java.io.IOException;
public class TryWithResourcesDemo {
public void readFile() {
// 资源声明在try括号内，执行完毕自动关闭
try (FileInputStream fis = new FileInputStream("file.txt")) {
// 处理文件内容
} catch (IOException e) {
e.printStackTrace();
}
// 无需finally，资源自动关闭
}
}核心要点总结
finally块始终执行 （除非调用System.exit()终止程序）；finally中的return会覆盖try/catch的返回值，还可能 "吞掉" 异常，务必避免使用；- 返回基本类型时暂存值，
finally修改不影响结果；返回引用类型时暂存地址，finally修改对象内容会影响结果； finally的正确用途是清理资源，Java 7 + 推荐使用try-with-resources简化资源管理。
六、高频面试题解析
面试题 1（选择题）
以下关于 Java 中finally和return的说法，正确的是（）
A. finally块永远会执行
B. finally中的return会覆盖try/catch中的return值
C. 若try中返回基本类型，finally修改该值会影响返回结果
D. finally块中使用return可能会隐藏异常
答案：BD
解析：
- A 错误：
finally块并非 "永远执行"，若程序调用System.exit(0)强制终止 JVM，finally不会执行； - B 正确：
finally中的return会直接覆盖try/catch的返回值，是面试核心考点； - C 错误：基本类型返回时会暂存值，
finally修改不会影响最终返回结果； - D 正确：
finally中的return会 "吞掉"try块抛出的异常，导致异常无法暴露，隐藏程序问题。
面试题 2（代码分析题）
分析以下代码的执行结果，并说明执行顺序：
java
运行
public class InterviewTest1 {
public static int getNum() {
int num = 10;
try {
num = 20;
return num;
} finally {
num = 30;
System.out.println("finally中的num：" + num);
}
}
public static void main(String[] args) {
System.out.println("最终返回值：" + getNum());
}
}执行结果：
text
finally中的num：30
最终返回值：20解析：
- 执行
try块：num赋值为 20，遇到return语句，暂存num的值（20）； - 执行
finally块：num赋值为 30，打印 "finally 中的 num：30"； - 返回
try块中暂存的 20，因此最终输出 20； - 核心考点：基本类型返回时暂存的是 "值"，而非变量本身，
finally修改变量不影响返回结果。
面试题 3（代码分析题）
分析以下代码的执行结果，并说明风险点：
java
运行
public class InterviewTest2 {
public static String getStr() {
String str = "abc";
try {
int i = 1 / 0; // 抛出异常
return str;
} finally {
str = "def";
return str;
}
}
public static void main(String[] args) {
System.out.println(getStr());
}
}执行结果：
text
def解析：
- 执行
try块：定义str="abc"，执行1/0抛出算术异常，try的return未执行； - 执行
finally块：str赋值为def，执行return str； - 最终返回
def，且try块的算术异常被 "吞掉"，无任何异常提示。
风险点 ：finally中使用return导致try块的异常被隐藏，开发中无法感知程序出现了除零异常，排查问题时极易踩坑，这是面试中重点强调的 "不良实践"。
面试题 4（进阶题）
分析以下代码的执行结果，对比引用类型与基本类型的区别：
java
运行
public class InterviewTest3 {
static class User {
String name;
public User(String name) {
this.name = name;
}
}
public static User getUser() {
User user = new User("张三");
try {
return user;
} finally {
user.name = "李四";
System.out.println("finally中的用户名：" + user.name);
}
}
public static void main(String[] args) {
User u = getUser();
System.out.println("最终返回的用户名：" + u.name);
}
}执行结果：
text
finally中的用户名：李四
最终返回的用户名：李四解析：
- 执行
try块：创建User对象（name = 张三），遇到return语句，暂存该对象的内存地址； - 执行
finally块：通过内存地址修改对象的name属性为 "李四"，打印 "finally 中的用户名：李四"； - 返回暂存的对象地址，主函数通过该地址获取对象，
name已被修改为 "李四"； - 核心考点：引用类型返回时暂存的是 "地址"，
finally修改对象内容会影响最终返回结果，这是与基本类型的核心区别。