是的，会的。唯一不会发生的情况是JVM退出或崩溃

无论异常处理与否，Finally块始终执行。如果在try块之前发生任何异常，那么Finally块将不会执行。

我试过了，它是单线程的。

public static void main(String args[]) throws Exception {
    Object obj = new Object();
    try {
        synchronized (obj) {
            obj.wait();
            System.out.println("after wait()");
        }
    } catch (Exception ignored) {
    } finally {
        System.out.println("finally");
    }
}

主线程将永远处于等待状态，因此最终不会被调用，

因此控制台输出不会在wait（）或finally之后打印String:

同意@Stephen C的观点，上述示例是这里提到的第三个案例之一：

在以下代码中添加更多这样的无限循环可能性：

// import java.util.concurrent.Semaphore;

public static void main(String[] args) {
    try {
        // Thread.sleep(Long.MAX_VALUE);
        // Thread.currentThread().join();
        // new Semaphore(0).acquire();
        // while (true){}
        System.out.println("after sleep join semaphore exit infinite while loop");
    } catch (Exception ignored) {
    } finally {
        System.out.println("finally");
    }
}

案例2：如果JVM首先崩溃

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public static void main(String args[]) {
    try {
        unsafeMethod();
        //Runtime.getRuntime().halt(123);
        System.out.println("After Jvm Crash!");
    } catch (Exception e) {
    } finally {
        System.out.println("finally");
    }
}

private static void unsafeMethod() throws NoSuchFieldException, IllegalAccessException {
    Field f = Unsafe.class.getDeclaredField("theUnsafe");
    f.setAccessible(true);
    Unsafe unsafe = (Unsafe) f.get(null);
    unsafe.putAddress(0, 0);
}

参考：如何使JVM崩溃？

情况6：如果finally块将由守护程序线程执行，并且所有其他非守护程序线程在finally被调用之前退出。

public static void main(String args[]) {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            try {
                printThreads("Daemon Thread printing");
                // just to ensure this thread will live longer than main thread
                Thread.sleep(10000);
            } catch (Exception e) {
            } finally {
                System.out.println("finally");
            }
        }
    };
    Thread daemonThread = new Thread(runnable);
    daemonThread.setDaemon(Boolean.TRUE);
    daemonThread.setName("My Daemon Thread");
    daemonThread.start();
    printThreads("main Thread Printing");
}

private static synchronized void printThreads(String str) {
    System.out.println(str);
    int threadCount = 0;
    Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
    for (Thread t : threadSet) {
        if (t.getThreadGroup() == Thread.currentThread().getThreadGroup()) {
            System.out.println("Thread :" + t + ":" + "state:" + t.getState());
            ++threadCount;
        }
    }
    System.out.println("Thread count started by Main thread:" + threadCount);
    System.out.println("-------------------------------------------------");
}

输出：这不会打印“finally”，这意味着“守护进程线程”中的“finally块”没有执行

主螺纹打印线程：线程[My Daemon线程，5，main]：状态：BLOCKED线程：线程[main，5，main]：状态：RUNNABLE线程：线程[Monitor Ctrl-Break，5，main]：状态：RUNNABLE主线程启动的线程计数：3------------------------------------------------- Daemon线程打印线程：线程[My Daemon线程，5，main]：状态：RUNNABLE线程：线程[Monitor Ctrl-Break，5，main]：状态：RUNNABLE主线程启动的线程计数：2------------------------------------------------- 进程已完成，退出代码为0

最后总是在结尾处调用

当您尝试时，它会执行一些代码，如果在尝试中发生了什么，那么catch将捕获该异常，您可以打印一些mssg或抛出错误，然后最后执行块。

Finally通常在执行清理时使用，例如，如果使用java中的扫描仪，则可能应该关闭扫描仪，因为它会导致其他问题，例如无法打开某些文件

不，并非总是有一种例外情况//System.exit（0）；在finally块阻止finally被执行之前。

  class A {
    public static void main(String args[]){
        DataInputStream cin = new DataInputStream(System.in);
        try{
            int i=Integer.parseInt(cin.readLine());
        }catch(ArithmeticException e){
        }catch(Exception e){
           System.exit(0);//Program terminates before executing finally block
        }finally{
            System.out.println("Won't be executed");
            System.out.println("No error");
        }
    }
}

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