此外，finally的返回将丢弃任何异常。http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

下面是凯文的回答。重要的是要知道，要返回的表达式在finally之前求值，即使在finally之后返回。

public static void main(String[] args) {
    System.out.println(Test.test());
}

public static int printX() {
    System.out.println("X");
    return 0;
}

public static int test() {
    try {
        return printX();
    }
    finally {
        System.out.println("finally trumps return... sort of");
        return 42;
    }
}

输出：

X
finally trumps return... sort of
42

考虑以下程序：

public class SomeTest {

    private static StringBuilder sb = new StringBuilder();

    public static void main(String args[]) {

        System.out.println(someString());
        System.out.println("---AGAIN---");
        System.out.println(someString());
        System.out.println("---PRINT THE RESULT---");
        System.out.println(sb.toString());
    }

    private static String someString() {

        try {
            sb.append("-abc-");
            return sb.toString();

        } finally {
            sb.append("xyz");
        }
    }
}

从Java 1.8.162开始，上述代码块提供以下输出：

-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT THE RESULT---
-abc-xyz-abc-xyz

这意味着使用finally释放对象是一种很好的做法，如以下代码所示：

private static String someString() {

    StringBuilder sb = new StringBuilder();

    try {
        sb.append("abc");
        return sb.toString();

    } finally {
        sb = null; // Just an example, but you can close streams or DB connections this way.
    }
}

finally块总是在返回x（计算）值之前执行。

System.out.println("x value from foo() = " + foo());

...

int foo() {
  int x = 2;
  try {
    return x++;
  } finally {
    System.out.println("x value in finally = " + x);
  }
}

输出：

最终x值=3来自foo（）的x值=2

最终将执行，这是肯定的。

在以下情况下，finally将不执行：

案例1：

执行System.exit（）时。

案例2：

当JVM/线程崩溃时。

案例3：

手动停止执行时。

以下是一些可以绕过finally块的条件：

如果在执行try或catch代码时JVM退出，那么finally块可能不会执行。更多太阳教程正常关闭-当最后一个非守护程序线程退出时，或者当Runtime.exit（）（一些不错的博客）时，都会发生这种情况。当线程退出时，JVM会对正在运行的线程进行盘点，如果只剩下守护进程线程，则会启动有序关闭。当JVM停止时，所有剩余的守护程序线程都将被放弃。如果不执行块，堆栈也不会被解开，JVM只会退出。守护程序线程应该很少使用，很少有处理活动可以在任何时候安全地放弃，而无需清理。特别是，将守护程序线程用于可能执行任何类型I/O的任务是危险的。守护程序线程最好保存用于“内务管理”任务，例如后台线程，它定期从内存缓存中删除过期条目（源）

最后一个非守护程序线程退出示例：

public class TestDaemon {
    private static Runnable runnable = new Runnable() {
        @Override
        public void run() {
            try {
                while (true) {
                    System.out.println("Is alive");
                    Thread.sleep(10);
                    // throw new RuntimeException();
                }
            } catch (Throwable t) {
                t.printStackTrace();
            } finally {
                System.out.println("This will never be executed.");
            }
        }
    };

    public static void main(String[] args) throws InterruptedException {
        Thread daemon = new Thread(runnable);
        daemon.setDaemon(true);
        daemon.start();
        Thread.sleep(100);
        // daemon.stop();
        System.out.println("Last non-daemon thread exits.");
    }
}

输出：

Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Last non-daemon thread exits.
Is alive
Is alive
Is alive
Is alive
Is alive