Да, finally будет вызываться после выполнения кодовых блоков try или catch.

finally не будет вызван только в следующих случаях:

1. Если вы вызываете System.exit()
2. Если вы вызываете Runtime.getRuntime().halt(exitStatus)
3. Если сначала произойдет сбой JVM
4. Если JVM достигает бесконечного цикла (или некоторого другого непрерываемого, не завершающего оператора) в блоке try или catch
5. Если ОС принудительно завершает процесс JVM; например, kill -9 <pid> в UNIX
6. Если хост-система умирает; например, сбой питания, аппаратная ошибка, паника ОС и т. д.
7. Если блок finally будет выполняться потоком демона, а все другие потоки, не являющиеся демонами, завершаются до вызова finally

finally всегда выполняется, если нет аварийного завершения программы (например, вызов System.exit (0) ..). Итак, ваш sysout будет напечатан

Да, позвонят. В этом весь смысл ключевого слова finally. Если выпрыгивание из блока try / catch могло просто пропустить блок finally, это было то же самое, что поместить System.out.println вне try / catch.

Пример кода:

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

public static int test() {
    try {
        return 0;
    }
    finally {
        System.out.println("finally trumps return.");
    }
}

Выход:

finally trumps return. 
0

На самом деле это верно для любого языка ... finally всегда будет выполняться перед оператором return, независимо от того, где этот return находится в теле метода. Если бы это было не так, блок finally не имел бы особого значения.

Блок finally всегда выполняется, если не происходит аварийного завершения программы, либо в результате сбоя JVM, либо в результате вызова System.exit(0).

Кроме того, любое значение, возвращаемое из блока finally, переопределит значение, возвращенное до выполнения блока finally, поэтому будьте осторожны при проверке всех точек выхода при использовании try finally.

Кроме того, несмотря на то, что это плохая практика, если в блоке finally есть оператор return, он будет превосходить любой другой возврат из обычного блока. То есть следующий блок вернет false:

try { return true; } finally { return false; }

То же самое с выдачей исключений из блока finally.

Также возврат в finally отбрасывает любое исключение. http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

Логичный способ подумать об этом:

1. Код, помещенный в блок finally, должен выполняться что бы ни случилось в блоке try
2. Поэтому, если код в блоке try пытается вернуть значение или вызвать исключение, элемент помещается `` на полку '' до тех пор, пока блок finally не сможет выполнить
3. Поскольку код в блоке finally имеет (по определению) высокий приоритет, он может возвращать или отбрасывать все, что ему нравится. В этом случае все, что осталось «на полке», выбрасывается.
4. Единственное исключение из этого - если виртуальная машина полностью выключается во время блока попытки, например. от 'System.exit'

В дополнение к пункту о возврате при окончательной замене возврата в блоке try то же самое верно и для исключения. Блок finally, который генерирует исключение, заменяет возврат или исключение, выданное из блока try.

Я пробовал приведенный выше пример с небольшими изменениями -

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

public static int test() {
    int i = 0;
    try {
        i = 2;
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
    }
}

Приведенный выше код выводит:

finally trumps return.
2

Это потому, что, когда выполняется return i;, i имеет значение 2. После этого выполняется блок finally, где 12 назначается i, а затем выполняется System.out out.

После выполнения блока finally блок try возвращает 2, а не 12, потому что этот оператор возврата не выполняется снова.

Если вы будете отлаживать этот код в Eclipse, то у вас возникнет ощущение, что после выполнения System.out блока finally снова выполняется инструкция return блока try. Но это не так. Он просто возвращает значение 2.

Наконец, всегда выполняется, в этом вся суть, просто потому, что он появляется в коде после возврата, не означает, что это реализовано именно так. Среда выполнения Java отвечает за запуск этого кода при выходе из блока try.

Например, если у вас есть следующее:

int foo() { 
    try {
        return 42;
    }
    finally {
        System.out.println("done");
    }
}

Среда выполнения сгенерирует что-то вроде этого:

int foo() {
    int ret = 42;
    System.out.println("done");
    return 42;
}

Если генерируется неперехваченное исключение, запускается блок finally, и исключение продолжает распространяться.

Потому что блок finally всегда будет вызываться, если вы не вызовете System.exit() (или поток не выйдет из строя).

В этом вся идея блока finally. Это позволяет вам убедиться, что вы выполняете очистку, которую в противном случае можно было бы пропустить из-за того, что вы вернетесь, среди прочего, конечно.

Наконец, в блоке try вызывается независимо от того, что происходит (пока не вы вызываете System.exit(int), или виртуальная машина Java отключается по какой-то другой причине).

Потому что финал всегда вызывается в любых случаях, которые у вас есть. У вас нет исключения, оно все еще вызывается, перехватывает исключение, оно все еще вызывается

В дополнение к другим ответам важно указать, что 'finally' имеет право переопределить любое исключение / возвращаемое значение блоком try..catch. Например, следующий код возвращает 12:

public static int getMonthsInYear() {
    try {
        return 10;
    }
    finally {
        return 12;
    }
}

Точно так же следующий метод не вызывает исключения:

public static int getMonthsInYear() {
    try {
        throw new RuntimeException();
    }
    finally {
        return 12;
    }
}

Хотя следующий метод его бросает:

public static int getMonthsInYear() {
    try {
        return 12;          
    }
    finally {
        throw new RuntimeException();
    }
}

Рассмотрим это при нормальном ходе выполнения (то есть без какого-либо исключения): если метод не является `` недействительным '', тогда он всегда явно что-то возвращает, но, наконец, всегда выполняется

Это потому, что вы присвоили i значение 12, но не вернули значение i функции. Правильный код выглядит следующим образом:

public static int test() {
    int i = 0;
    try {
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
        return i;
    }
}

Вот официальные слова из спецификации языка Java.

14.20.2. Выполнение try-finally и try-catch-finally

A try statement with a finally block is executed by first executing the try block. Then there is a choice:

• If execution of the try block completes normally, [...]
• If execution of the try block completes abruptly because of a throw of a value V, [...]
• If execution of the try block completes abruptly for any other reason R, then the finally block is executed. Then there is a choice:
  • If the finally block completes normally, then the try statement completes abruptly for reason R.
  • If the finally block completes abruptly for reason S, then the try statement completes abruptly for reason S (and reason R is discarded).

Спецификация return фактически делает это явным:

JLS 14.17 Заявление о возврате

ReturnStatement:
     return Expression(opt) ;

A return statement with no Expressionattempts to transfer control to the invoker of the method or constructor that contains it.

A return statement with an Expressionattempts to transfer control to the invoker of the method that contains it; the value of the Expression becomes the value of the method invocation.

The preceding descriptions say "attempts to transfer control" rather than just "transfers control" because if there are any try statements within the method or constructor whose try blocks contain the return statement, then any finally clauses of those try statements will be executed, in order, innermost to outermost, before control is transferred to the invoker of the method or constructor. Abrupt completion of a finally clause can disrupt the transfer of control initiated by a return statement.

Если выбрано исключение, функция finally выполняется. Если исключение не сгенерировано, функция finally выполняется. Если исключение обнаружено, наконец запускается. Если исключение не обнаружено, функция finally выполняется.

Он не запускается только тогда, когда JVM завершает работу.

Попробуйте этот код, вы поймете код в блоке finally выполняется после оператора возврата.

public class TestTryCatchFinally {
    static int x = 0;

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

    public static int f1(){
        try{
            x = 1;
            return x;
        }finally{
            x = 2;
        }
    }

    public static int f2(){
        return x;
    }
}

Нет, не всегда одним исключением является // 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");
        }
    }
}

Да, это будет. Независимо от того, что происходит в вашем блоке try или catch, если только не вызывается System.exit () или JVM не аварийно завершается. если в блоке (ах) есть какой-либо оператор возврата, он будет выполнен до этого оператора возврата.

Вот разработка Ответ Кевина. Важно знать, что возвращаемое выражение оценивается до 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");
    }
}

Выход:

X
finally trumps return... sort of
0

Да, это будет. Только в том случае, если этого не произойдет, это выход из JVM или сбой

Блок finally всегда выполняется независимо от того, обрабатывается ли исключение или нет. Если какое-либо исключение произошло до блока try, блок finally не будет выполняться.

Вкратце, в официальной документации Java (щелкните здесь) написано, что -

If the JVM exits while the try or catch code is being executed, then the finally block may not execute. Likewise, if the thread executing the try or catch code is interrupted or killed, the finally block may not execute even though the application as a whole continues.

Да, блок finally всегда выполняется. Большинство разработчиков используют этот блок для закрытия соединения с базой данных, объекта набора результатов, объекта оператора, а также используют его в спящем режиме java для отката транзакции.

finally будет работать, и это точно.

finally не будет выполняться в следующих случаях:

Случай 1 :

Когда вы выполняете System.exit().

случай 2:

Когда ваша JVM / Thread аварийно завершает работу.

случай 3:

Когда ваше выполнение остановлено вручную.

Я был очень смущен всеми ответами, представленными на разных форумах, и решил наконец написать код и посмотреть. Выход:

finally будет выполняться, даже если в блоке try и catch есть возврат.

try {  
  System.out.println("try"); 
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} catch (Exception e) {   
  System.out.println("catch");
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} finally {  
   System.out.println("Print me FINALLY");
}

Выход

try

Print me FINALLY

2. Если return заменяется на System.exit(0) в блоке try and catch в приведенном выше коде и перед ним возникает исключение по любой причине.

НЕ ВСЕГДА

Спецификация языка Java описывает, как блоки try-catch-finally и try-catch работают в 14.20.2
. Нигде не указано, что блок finally выполняется всегда. Но для всех случаев, когда блоки try-catch-finally и try-finally завершаются, он указывает, что до завершения должен быть выполнен finally.

try {
  CODE inside the try block
}
finally {
  FIN code inside finally block
}
NEXT code executed after the try-finally block (may be in a different method).

JLS не гарантирует, что ПЛАВНИК выполняется после КОД. JLS гарантирует, что если выполняются КОД и СЛЕДУЮЩИЙ, то ПЛАВНИК всегда будет выполняться после КОД и перед СЛЕДУЮЩИЙ.

Почему JLS не гарантирует, что блок finally всегда выполняется после блока try? Потому что это невозможно. Маловероятно, но возможно, что JVM будет прервана (уничтожение, сбой, отключение питания) сразу после завершения блока try, но до выполнения блока finally. JLS ничего не может сделать, чтобы этого избежать.

Таким образом, любое программное обеспечение, правильное поведение которого зависит от того, что блоки finally всегда выполняются после того, как их блоки try завершены, ошибаются.

Инструкции return в блоке try не имеют отношения к этой проблеме. Если выполнение достигает кода после try-catch-finally, гарантируется, что блок finally будет выполнен раньше, с инструкциями return внутри блока try или без них.

Я пробовал это, Он однопоточный.

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");
    }
}

mainThread навсегда останется в состоянии wait, следовательно, finally никогда не будет называться,

поэтому вывод консоли не будет printString: после wait() или finally

Согласованный с @Stephen C, приведенный выше пример является одним из 3-го случая упоминания здесь:

Добавляем еще несколько таких возможностей бесконечного цикла в следующий код:

// 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 будет выполняться демоном Thread, а все остальные, кроме демона, Threads завершат работу до вызова 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» в «потоке демона» не был выполнен

main Thread Printing  
Thread :Thread[My Daemon Thread,5,main]:state:BLOCKED  
Thread :Thread[main,5,main]:state:RUNNABLE  
Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE   
Thread count started by Main thread:3  
-------------------------------------------------  
Daemon Thread printing  
Thread :Thread[My Daemon Thread,5,main]:state:RUNNABLE  
Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE  
Thread count started by Main thread:2  
-------------------------------------------------  

Process finished with exit code 0

finally также может быть преждевременно завершен, если Exception является thrown внутри вложенный блок finally. Компилятор предупредит вас о том, что блок finally не завершается нормально, или выдаст ошибку о недоступности кода. Ошибка для недоступного кода будет отображаться только в том случае, если throw не находится за условным оператором или внутри цикла.

try{
}finally{
   try{
   }finally{
      //if (someCondition) --> no error because of unreachable code
      throw new RunTimeException();
   }
   int a = 5;//unreachable code
}

То же самое со следующим кодом:

static int f() {
    while (true) {
        try {
            return 1;
        } finally {
            break;
        }
    }
    return 2;
}

f вернет 2!

Answer is simple YES.

ВХОД:

try{
    int divideByZeroException = 5 / 0;
} catch (Exception e){
    System.out.println("catch");
    return;    // also tried with break; in switch-case, got same output
} finally {
    System.out.println("finally");
}

ВЫХОД:

catch
finally

Да, он всегда будет вызываться, но в одной ситуации он не вызывается, когда вы используете System.exit ()

try{
//risky code
}catch(Exception e){
//exception handling code
}
finally(){
//It always execute but before this block if there is any statement like System.exit(0); then this block not execute.
}

1. Наконец, блок всегда выполняется. Если и пока Здесь существует оператор System.exit () (первый оператор в блоке finally).
2. Если system.exit () является первым оператором, то блок finally не будет выполняться, и управление будет передано из блока finally. Всякий раз, когда оператор System.exit () попадает в блок finally, до тех пор, пока этот блок не будет выполнен, и когда появится System.exit (), тогда управляющая сила полностью выйдет из блока finally.

Если вы не обрабатываете исключение, перед завершением программы JVM выполняет блок finally. Он не будет выполнен только в том случае, если нормальное выполнение программы завершится неудачей, что означает завершение программы по следующим причинам:

1. Вызывая фатальную ошибку, приводящую к прерыванию процесса.

2. Завершение программы из-за повреждения памяти.

3. Вызывая System.exit ()

4. Если программа переходит в бесконечный цикл.

Блок finally не будет вызываться после возврата в нескольких уникальных сценариях: если сначала вызывается System.exit () или если JVM дает сбой.

Позвольте мне попытаться ответить на ваш вопрос как можно проще.

Правило 1: блок finally всегда выполняется (Хотя есть исключения из этого. Но давайте пока останемся на этом.)

Правило 2: операторы в блоке finally выполняются, когда управление выходит из блока try или catch. Передача управления может происходить в результате нормального выполнения, выполнения оператора break, continue, goto или return или распространения исключения.

В случае конкретного оператора return (поскольку он подписан) элемент управления должен покинуть вызывающий метод и, следовательно, вызывает блок finally соответствующей структуры try-finally. Оператор return выполняется после блока finally.

Если в блоке finally также есть оператор return, он определенно переопределит оператор, ожидающий в блоке try, поскольку он очищает стек вызовов.

Вы можете сослаться на лучшее объяснение здесь: http://msdn.microsoft.com/en-us/ .... концепция в основном одинакова для всех языков высокого уровня.

Да, потому что нет контрольного заявления может предотвратить выполнение finally.

Вот справочный пример, в котором будут выполняться все блоки кода:

| x | Current result | Code 
|---|----------------|------ - - -
|   |                |     
|   |                | public static int finallyTest() {
| 3 |                |     int x = 3;
|   |                |     try {
|   |                |        try {
| 4 |                |             x++;
| 4 | return 4       |             return x;
|   |                |         } finally {
| 3 |                |             x--;
| 3 | throw          |             throw new RuntimeException("Ahh!");
|   |                |         }
|   |                |     } catch (RuntimeException e) {
| 4 | return 4       |         return ++x;
|   |                |     } finally {
| 3 |                |         x--;
|   |                |     }
|   |                | }
|   |                |
|---|----------------|------ - - -
|   | Result: 4      |

В варианте ниже return x; будет пропущен. Результат по-прежнему 4:

public static int finallyTest() {
    int x = 3;
    try {
        try {
            x++;
            if (true) throw new RuntimeException("Ahh!");
            return x; // skipped
        } finally {
            x--;
        }
    } catch (RuntimeException e) {
        return ++x;
    } finally {
        x--;
    }
}

Ссылки, конечно же, отслеживают их статус. Этот пример возвращает ссылку с value = 4:

static class IntRef { public int value; }
public static IntRef finallyTest() {
    IntRef x = new IntRef();
    x.value = 3;
    try {
        return x;
    } finally {
        x.value++; // will be tracked even after return
    }
}

Да написано здесь

If the JVM exits while the try or catch code is being executed, then the finally block may not execute. Likewise, if the thread executing the try or catch code is interrupted or killed, the finally block may not execute even though the application as a whole continues.

Добавление к Ответ @ vibhash, поскольку никакой другой ответ не объясняет, что происходит в случае изменяемого объекта, подобного приведенному ниже.

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

public static StringBuffer test() {
    StringBuffer s = new StringBuffer();
    try {
        s.append("sb");
        return s;
    } finally {
        s.append("updated ");
    }
}

Будет выводить

sbupdated 

try- catch- finally - ключевые слова для использования случая обработки исключений. Как обычная пояснительная

try {
     //code statements
     //exception thrown here
     //lines not reached if exception thrown
} catch (Exception e) {
    //lines reached only when exception is thrown
} finally {
    // always executed when the try block is exited
    //independent of an exception thrown or not
}

Блок finally предотвращает выполнение ...

• Когда вы позвонили в System.exit(0);
• Если JVM завершает работу.
• Ошибки в JVM

Блок finally выполняется всегда, даже если вы поместите оператор return в блок try. Блок finally будет выполнен перед оператором return.

Рассмотрим следующую программу:

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.
    }
}

Наконец, всегда вызывается в конце

когда вы пытаетесь, он выполняет некоторый код, если что-то происходит при попытке, тогда catch перехватит это исключение, и вы можете вывести какое-то сообщение mssg или выдать ошибку, затем выполняется блок finally.

Наконец, обычно используется при очистке, например, если вы используете сканер в java, вам, вероятно, следует закрыть сканер, поскольку это приводит к другим проблемам, таким как невозможность открыть какой-либо файл.

Вот некоторые условия, которые могут обойти блок finally:

1. Если JVM завершает работу во время выполнения кода try или catch, то блок finally может не выполняться. Подробнее о солнце учебник
2. Нормальное завершение работы - это происходит либо при выходе из последнего недемонического потока, либо при Runtime.exit () (какой-то хороший блог). Когда поток завершается, JVM выполняет инвентаризацию запущенных потоков, и если единственные оставшиеся потоки являются потоками демона, она инициирует упорядоченное завершение работы. Когда JVM останавливается, все оставшиеся потоки демона прекращаются, в конце концов, блоки не выполняются, стеки не разматываются, JVM просто завершает работу. Демонические потоки следует использовать с осторожностью, от некоторых операций обработки можно безопасно отказаться в любое время без очистки. В частности, опасно использовать потоки демонов для задач, которые могут выполнять какой-либо ввод-вывод. Потоки демона лучше всего сохранять для «служебных» задач, таких как фоновый поток, который периодически удаляет просроченные записи из кеша в памяти (источник)

Пример выхода последнего недемонического потока:

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

finally выполняется всегда и перед возвратом (вычисленного) значения x.

System.out.println(foo());

....

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

Выход:

3
2

пример попытки с ресурсом

static class IamAutoCloseable implements AutoCloseable {
    private final String name;
    IamAutoCloseable(String name) {
        this.name = name;
    }
    public void close() {
        System.out.println(name);
    }
}

@Test
public void withResourceFinally() {
    try (IamAutoCloseable closeable1 = new IamAutoCloseable("closeable1");
         IamAutoCloseable closeable2 = new IamAutoCloseable("closeable2")) {
        System.out.println("try");
    } finally {
        System.out.println("finally");
    }
}

Тестовый результат:

try
closeable2
closeable1
finally