Java final、finally、finalize 区别

背景与动机#

final、finally、finalize 名字很像，初学者和面试场景里经常被放在一起问，但它们完全不是同一类东西：

• final 是关键字，用来限制“能不能改”
• finally 是异常处理语法块，用来保证“收尾动作会执行”
• finalize 是 Object 里的方法，和垃圾回收有关，但早已不推荐依赖

如果只记“三个 final 开头”，很容易混。这篇笔记把它们放在一张对照表里，再分别拆开看。

核心对比#

记忆口诀可以记成：

• final 管“定不变”
• finally 管“必收尾”
• finalize 管“回收前” —— 但这条在现代 Java 里已经过时

final：限制修改#

final 修饰的目标不同，含义也不同：

1
final class Config {
2
    final String env;
3

4
    Config(String env) {
5
        this.env = env;
6
    }
7

8
    final void printEnv() {
9
        System.out.println(env);
10
    }
11
}

上面这段里：

• final class Config：别人不能再写 class DevConfig extends Config
• final String env：构造完成后不能再给 env 重新赋值
• final void printEnv()：子类不能重写 printEnv()

注意：final 修饰引用类型时，限制的是“引用不能改”，不是“对象内部状态不能改”。

1
final java.util.List<String> names = new java.util.ArrayList<>();
2
names.add("java"); // 可以
3
names = new java.util.ArrayList<>(); // 编译错误

更完整的用法见 Java 封装、继承与多态 和 Java 变量与基本数据类型。

finally：异常处理里的收尾块#

finally 必须出现在 try 后面，用来放无论是否发生异常都要执行的逻辑，常见是关闭资源、写收尾日志。

1
java.io.BufferedReader reader = null;
2
try {
3
    reader = java.nio.file.Files.newBufferedReader(java.nio.file.Path.of("a.txt"));
4
    System.out.println(reader.readLine());
5
} catch (java.io.IOException e) {
6
    System.out.println("read fail: " + e.getMessage());
7
} finally {
8
    if (reader != null) {
9
        try {
10
            reader.close();
11
        } catch (java.io.IOException e) {
12
            e.printStackTrace();
13
        }
14
    }
15
}

几个边界要记住：

• finally 不是“处理异常”，而是“做收尾”
• 通常会在 return 之前执行，所以不建议在 finally 里写复杂返回逻辑
• 如果 JVM 直接退出、进程崩溃，finally 也可能没机会执行

现代 Java 里，关闭文件、流、连接这类资源，更推荐 try-with-resources：

1
try (java.io.BufferedReader reader =
2
         java.nio.file.Files.newBufferedReader(java.nio.file.Path.of("a.txt"))) {
3
    System.out.println(reader.readLine());
4
} catch (java.io.IOException e) {
5
    System.out.println("read fail: " + e.getMessage());
6
}

更完整的异常处理见 Java 异常处理。

finalize：GC 回收前的钩子（已废弃）#

finalize 是 Object 定义的 protected 方法：

1
protected void finalize() throws Throwable

理论上，对象失去引用、即将被垃圾回收前，JVM 可能调用一次 finalize()，让开发者做最后清理。

1
class TempFileHolder {
2
    private final String path;
3

4
    TempFileHolder(String path) {
5
        this.path = path;
6
    }
7

8
    @Override
9
    @Deprecated(since = "9", forRemoval = true)
10
    protected void finalize() {
11
        System.out.println("maybe cleanup: " + path);
12
    }
13
}

但它在实际开发里问题很多：

• 调用时机不确定：对象什么时候被回收，JVM 说了算，finalize() 可能很晚才执行，也可能根本不执行
• 性能差：会拖慢 GC，历史上还可能导致对象“复活”
• 不可靠：不能把它当成资源释放机制
• 已被废弃：Java 9 起标记 @Deprecated，后续版本继续推进移除

所以现代 Java 的正确做法是：

• 文件、连接、锁：用 try-with-resources 或显式 close()
• 需要更灵活的清理：Java 9+ 可以用 java.lang.ref.Cleaner
• 业务对象生命周期：由应用代码自己管理，不要等 GC

Object 其他常用方法见 Java Object 类。

最小可运行示例：三者同框#

1
public class FinalDemo {
2
    public static void main(String[] args) {
3
        System.out.println(readWithFinally());
4
    }
5

6
    static int readWithFinally() {
7
        try {
8
            return 1;
9
        } finally {
10
            System.out.println("finally runs before return");
11
        }
12
    }
13
}
14

15
final class Demo {
16
    final int value = 42;
17
}

运行 FinalDemo 会先打印 finally runs before return，再结束方法。

这段代码里：

• final class Demo 和 final int value 体现 final
• finally 块体现收尾执行时机
• 没有演示 finalize，因为正常项目里不应再依赖它

常见陷阱#

面试高频问题#

一句话总结#

final 定规则、finally 做收尾、finalize 曾是 GC 钩子但已过时；面试和写代码时，先分清“关键字、语法块、方法”这三层，再谈具体场景。