it-swarm-es.com

¿Un bloque finalmente se ejecuta siempre en Java?

Teniendo en cuenta este código, ¿puedo estar absolutamente seguro que el bloque finally siempre se ejecuta, sin importar lo que something() sea?

try {  
    something();  
    return success;  
}  
catch (Exception e) {   
    return failure;  
}  
finally {  
    System.out.println("I don't know if this will get printed out");
}
2159
jonny five

Sí, se llamará a finally después de la ejecución de los bloques de código try o catch.

Las únicas veces que no se llamará finally son:

  1. Si invocas System.exit()
  2. Si la JVM falla primero
  3. Si la JVM alcanza un bucle infinito (o alguna otra instrucción no interrumpible, sin terminación) en el bloque try o catch
  4. Si el SO termina por la fuerza el proceso de JVM; por ejemplo, kill -9 <pid> en UNIX
  5. Si el sistema host muere; por ejemplo, fallo de alimentación, error de hardware, pánico del sistema operativo, etc.
  6. Si el bloque finally va a ser ejecutado por un subproceso del daemon y todos los demás subprocesos que no son del demonio, saldrán antes de llamar a finally
2415
jodonnell

Código de ejemplo:

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

Salida:

finally trumps return. 
0
502
Kevin

Además, aunque es una mala práctica, si hay una declaración de retorno dentro del bloque finally, prevalecerá sobre cualquier otro retorno del bloque regular. Es decir, el siguiente bloque devolvería falso:

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

Lo mismo con lanzar excepciones del bloque finalmente.

362
MooBob42

Aquí están las palabras oficiales de la especificación del lenguaje Java.

14.20.2. Ejecución de try-finally y try-catch-finally

Una instrucción try con un bloque finally se ejecuta ejecutando primero el bloque try. Luego hay una opción:

  • Si la ejecución del bloque try se completa normalmente, [...]
  • Si la ejecución del bloque try se completa abruptamente debido a una throw de un valor V, [...]
  • Si la ejecución del bloque try se completa abruptamente por cualquier otra razón R, entonces se ejecuta el bloque finally. Entonces hay una opción:
    • Si el bloque finalmente se completa normalmente, entonces la instrucción try se completa abruptamente por la razón R.
    • Si el bloque finally se completa abruptamente por la razón S, entonces la instrucción try se completa abruptamente por la razón S (y la razón R se descarta).

La especificación para return realmente hace esto explícito:

JLS 14.17 La declaración de retorno

ReturnStatement:
     return Expression(opt) ;

Una instrucción return sin Expressionintentatransferir el control al invocador del método o constructor que lo contiene.

Una instrucción return con Expressionintentatransferir el control al invocador del método que lo contiene; el valor de Expression se convierte en el valor de la invocación del método.

Las descripciones anteriores dicen "intentatransferir control" en lugar de simplemente "transfers control" porque si hay alguna instrucción try dentro del método o constructor cuyos bloques try contengan la declaración return, entonces cualquier cláusula finally de esas declaraciones try se ejecutará, en orden, de lo más interno posible, antes de transferir el control al invocador del método o del constructor. La finalización abrupta de una cláusula finally puede interrumpir la transferencia del control iniciada por una declaración return.

249
polygenelubricants

Además de las otras respuestas, es importante señalar que 'finalmente' tiene el derecho de anular cualquier excepción/valor devuelto por el bloque try..catch. Por ejemplo, el siguiente código devuelve 12:

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

Del mismo modo, el siguiente método no lanza una excepción:

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

Mientras que el siguiente método lo lanza:

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

Probé el ejemplo anterior con una ligera modificación.

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

Las salidas del código anterior:

finalmente triunfa el regreso.
2

Esto se debe a que cuando return i; se ejecuta i tiene un valor 2. Después de esto, se ejecuta el bloque finally donde 12 se asigna a i y luego se ejecuta System.out out.

Después de ejecutar el bloque finally, el bloque try devuelve 2, en lugar de devolver 12, porque esta instrucción de retorno no se ejecuta de nuevo.

Si depura este código en Eclipse, tendrá la sensación de que después de ejecutar System.out de finally block, la instrucción return de try block se ejecutará de nuevo. Pero este no es el caso. Simplemente devuelve el valor 2.

109
vibhash

Aquí hay una elaboración de la respuesta de Kevin . Es importante saber que la expresión que se devolverá se evalúa antes de finally, incluso si se devuelve después.

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

Salida:

X
finally trumps return... sort of
0
95
WoodenKitty

Esa es toda la idea de un bloque finalmente. Le permite asegurarse de que realiza limpiezas que, de lo contrario, podrían omitirse porque, por supuesto, entre otras cosas, regresa.

Finalmente, se llama a independientemente de lo que ocurra en el bloque de prueba ( a menos que llame a System.exit(int) o la Máquina Virtual de Java salga por alguna otra razón).

52
Chris Cooper

Una manera lógica de pensar en esto es:

  1. El código colocado en un bloque finally debe ejecutarse lo que ocurra dentro del bloque try
  2. Por lo tanto, si el código en el bloque try intenta devolver un valor o lanzar una excepción, el elemento se coloca 'en el estante' hasta que el bloque finalmente pueda ejecutarse
  3. Debido a que el código en el bloque finally tiene (por definición) una prioridad alta, puede devolver o lanzar lo que quiera. En cuyo caso, todo lo que quede "en el estante" se desecha.
  4. La única excepción a esto es si VM se apaga completamente durante el bloque de prueba, p. Ej. por 'System.exit'
38
Garth Gilmour

finalmente, siempre se ejecuta a menos que haya una terminación anormal del programa (como llamar a System.exit (0) ..). así, tu sysout se imprimirá

18
shyam

También un retorno en finalmente tirará cualquier excepción. http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

18

El bloque finally se ejecuta siempre a menos que haya una terminación anormal del programa, ya sea como resultado de un bloqueo de JVM o de una llamada a System.exit(0).

Además de eso, cualquier valor devuelto desde el bloque finally anulará el valor devuelto antes de la ejecución del bloque finally, así que tenga cuidado de verificar todos los puntos de salida cuando use try finalmente.

17
user9189

No, no siempre un caso de excepción es // System.exit (0); antes de que el bloque finalmente impida finalmente ser ejecutado.

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

Finalmente, siempre se ejecuta ese es todo el punto, solo porque aparece en el código después de la devolución no significa que así se implementa. El tiempo de ejecución de Java tiene la responsabilidad de ejecutar este código al salir del bloque try.

Por ejemplo, si tiene lo siguiente:

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

El tiempo de ejecución generará algo como esto:

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

Si se lanza una excepción no detectada, el bloque finally se ejecutará y la excepción continuará propagándose.

12
Motti

Esto se debe a que asignó el valor de i como 12, pero no devolvió el valor de i a la función. El código correcto es el siguiente:

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

Porque siempre se llamará un bloque finally a menos que llames System.exit() (o el hilo se bloquee).

9
Jay Riggs

La respuesta es simpleS&IACUTE;.

ENTRADA:

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

SALIDA:

catch
finally
9
Meet

Sí se llamará. Ese es el punto central de tener una palabra clave finalmente. Si saltar fuera del bloque try/catch podría simplemente saltar el bloque final, sería lo mismo que poner System.out.println fuera del try/catch.

8
Mendelt

Sí, finalmente el bloque siempre se ejecuta. La mayoría de los desarrolladores utilizan este bloque para cerrar la conexión de la base de datos, el objeto del conjunto de resultados, el objeto de declaración y también los utilizan en la hibernación de Java para deshacer la transacción.

8
Gautam Viradiya

De manera concisa, en la documentación oficial de Java (haga clic en aquí ), está escrito que -

Si la JVM sale mientras se está ejecutando el código de prueba o captura, entonces el bloque finally puede no ejecutarse. Del mismo modo, si el subproceso que ejecuta el código try o catch se interrumpe o se elimina, el bloque finally puede no ejecutarse aunque la aplicación en su totalidad continúe.

8
bikz05

Si lo sera El único caso no es JVM sale o se bloquea

7
abhig

Si lo sera No importa lo que suceda en su bloque try o catch a menos que System.exit () sea llamado o JVM se bloquee. Si hay alguna declaración de devolución en el (los) bloque (es), finalmente se ejecutará antes de esa declaración de devolución.

7
Karthikeyan

Considere el siguiente programa:

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

A partir de Java 1.8.162, el bloque de código anterior da el siguiente resultado:

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

esto significa que usar finally para liberar objetos es una buena práctica como el siguiente código:

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

He intentado esto, es un solo hilo.

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

El hilo principal estará en estado de espera para siempre, por lo que finalmente nunca se llamará,

así que la salida de la consola no imprimirá la cadena: after wait() o finally

De acuerdo con @Stephen C, el ejemplo anterior es una de las referencias del tercer caso aquí :

Agregando más posibilidades de bucle infinito en el siguiente código:

// import Java.util.concurrent.Semaphore;
class Test {
    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 e) {
        } finally {
            System.out.println("finally");
        }
    }
}

Caso 2: Si la JVM se bloquea primero

import Sun.misc.Unsafe;
import Java.lang.reflect.Field;
class Test {
    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);
    }
}

Ref: ¿Cómo se bloquea una JVM?

Caso 6: si finalmente el bloque será ejecutado por el subproceso del daemon y todos los demás subprocesos que no son del demonio se cerrarán antes de que se llame finalmente.

class Test {
    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("-------------------------------------------------");
    }
}

salida: Esto no se imprime "finalmente", lo que implica que "Finalmente bloque" en "subproceso del demonio" no se ejecutó

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
6
dkb

Sí, porque ninguna declaración de control puede evitar que finally se ejecute.

Aquí hay un ejemplo de referencia, donde se ejecutarán todos los bloques de código:

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

En la variante a continuación, se omitirá return x;. El resultado sigue siendo 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--;
    }
}

Las referencias, por supuesto, rastrean su estado. Este ejemplo devuelve una referencia con 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
    }
}
6
Dávid Horváth

finally se ejecutará y eso es seguro.

finally no se ejecutará en los siguientes casos:

caso 1 :

Cuando estás ejecutando System.exit().

caso 2:

Cuando su JVM/Thread se bloquea.

caso 3:

Cuando su ejecución se detiene entre el manual.

6
Utkash Bhatt

try- catch- finally son las palabras clave para usar el caso de manejo de excepciones.
Como explicativo normal

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
}

El bloque finalmente evitará ejecutar ...

  • Cuando llamaste System.exit(0);
  • Si JVM sale.
  • Errores en la JVM
6

Si no maneja la excepción, antes de terminar el programa, JVM ejecuta finalmente el bloque. No se ejecutará solo si la ejecución normal del programa fallará la terminación del programa debido a las siguientes razones.

  1. Al causar un error fatal que causa el proceso de abortar.

  2. Terminación del programa debido a la memoria corrupta.

  3. Al llamar a System.exit ()

  4. Si el programa entra en un bucle infinito.

6

Eso es realmente cierto en cualquier idioma ... finalmente, siempre se ejecutará antes de una declaración de devolución, sin importar dónde se encuentre esa devolución en el cuerpo del método. Si ese no fuera el caso, el bloque finalmente no tendría mucho significado.

6
Scott Dorman

Agregando a la respuesta de @vibhash como ninguna otra respuesta explica lo que sucede en el caso de un objeto mutable como el de abajo.

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

Saldrá

sbupdated 
6
Pradeep Kumaresan

Sí, está escrito aquí

Si la JVM sale mientras se está ejecutando el código de prueba o captura, entonces el bloque finally puede no ejecutarse. Del mismo modo, si el subproceso que ejecuta el código try o catch se interrumpe o se elimina, el bloque finally puede no ejecutarse aunque la aplicación en su totalidad continúe.

5
Danail Tsvetanov

Además del punto sobre el retorno al reemplazar finalmente un retorno en el bloque try, lo mismo ocurre con una excepción. Un bloque finalmente que lanza una excepción reemplazará una devolución o excepción lanzada desde dentro del bloque try.

5
Alex Miller

NO SIEMPRE

La especificación del lenguaje Java describe cómo funcionan los bloques try-catch-finally y try-catch en 14.20.2
En ningún lugar especifica que el bloque finally siempre se ejecuta. Pero para todos los casos en los que los bloques try-catch-finally y try-finally se completan, sí se especifica que, antes de completarse, finalmente se debe ejecutar.

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

El JLS no garantiza queFINse ejecute después deC&OACUTE;DIGO. El JLS garantiza que si se ejecutaC&OACUTE;DIGOySIGUIENTEentoncesFINsiempre se ejecutará después deC&OACUTE;DIGOy antes deSIGUIENTE.

¿Por qué el JLS no garantiza que el bloque finally se ejecute siempre después del bloque try? Porque es imposible. Es poco probable, pero es posible que la JVM sea abortada (matar, bloquear, apagar) justo después de completar el bloque de prueba pero antes de la ejecución del bloque final. No hay nada que el JLS pueda hacer para evitar esto.

Por lo tanto, cualquier software que para su comportamiento correcto depende de que finalmente se bloqueen los bloques que siempre se ejecutan después de que se completen los bloques de prueba, se ha interrumpido.

Las devoluciones en el bloque de prueba son irrelevantes para este problema. Si la ejecución alcanza el código después de try-catch-finalmente, se garantiza que el bloque finally se habrá ejecutado antes, con o sin retornos dentro del bloque try.

El bloque finally no se llamará después de regresar en un par de escenarios únicos: si se llama primero a System.exit (), o si la JVM se bloquea.

Déjame intentar responder a tu pregunta de la manera más fácil posible.

Regla 1 : El bloque finally siempre se ejecuta (aunque hay excepciones, pero mantengámonos en esto por algún tiempo).

Regla 2 : las instrucciones en la ejecución del bloque finally cuando el control deja un bloque try o catch. La transferencia del control puede ocurrir como resultado de la ejecución normal, de la ejecución de un break, continue, goto o a Declaración de retorno, o de una propagación de una excepción.

En el caso de una declaración de retorno específicamente (ya que está subtitulada), el control debe abandonar el método de llamada, y por lo tanto, llama al bloque finally de la estructura try-finally correspondiente. La declaración de retorno se ejecuta después del bloque finally.

En caso de que también haya una declaración de retorno en el bloque finally, definitivamente anulará la pendiente en el bloque try, ya que está eliminando la pila de llamadas.

Puede referirse a una mejor explicación aquí: http://msdn.Microsoft.com/en-us/ .... el concepto es casi igual en todos los lenguajes de alto nivel.

5
Sandip Solanki
  1. Finalmente el bloque siempre se ejecuta. A menos y hasta que System.exit () statement existe allí (primera sentencia en el bloque finalmente).
  2. Si system.exit () es la primera declaración, finalmente el bloque no se ejecutará y el control saldrá del bloque finally. Cada vez que la instrucción System.exit () entra finalmente en un bloque hasta que esa instrucción finalmente se ejecuta y cuando System.exit aparece, la fuerza de control sale completamente del bloque finally.
5
Avinash Pande

Lo mismo con el siguiente código:

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

f volverá 2!

4
dibo

Porque la final siempre se llama en cualquier caso que tengas. No tiene una excepción, todavía se llama, captura la excepción, todavía se llama

4
vodkhang

Sí, siempre se llamará, pero en una situación no se llama cuando usa 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.
}
4
Akash Manngroliya

Finalmente, el bloque siempre se ejecuta, ya sea que se trate de una excepción o no. Si se produjo alguna excepción antes del bloque de prueba, el bloque finalmente no se ejecutará.

4
Rohit Chugh

Si se lanza una excepción, finalmente se ejecuta. Si no se lanza una excepción, finalmente se ejecuta. Si la excepción es atrapada, finalmente se ejecuta. Si la excepción no es atrapada, finalmente se ejecuta.

La única vez que no se ejecuta es cuando sale JVM.

4
Bhushan

Considere esto en un curso normal de ejecución (es decir, sin que se lance ninguna excepción): si el método no es 'vacío', entonces siempre devuelve algo explícitamente, pero finalmente, siempre se ejecuta

4
Gala101

Pruebe este código, entenderá que el código en el bloque finalmente se ejecuta después de la declaración de retorno .

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;
    }
}
4
eric2323223

Estaba muy confundido con todas las respuestas proporcionadas en diferentes foros y decidí finalmente codificar y ver. La salida es:

finalmente se ejecutará incluso si hay retorno en el bloque try and 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");
}

Salida

tratar

Imprímeme FINALMENTE

  1. Si la devolución se sustituye por System.exit(0) en el bloque try and catch en el código anterior y se produce una excepción antes de ello, por cualquier motivo.
4
milton

finalmente, también se puede salir prematuramente si se lanza una excepción dentro de un bloque anidado finalmente. El compilador le avisará que el bloque finally no se completa normalmente o le dará un error que indica que tiene un código inalcanzable. El error para el código inalcanzable se mostrará solo si el lanzamiento no está detrás de una declaración condicional o dentro de un bucle.

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

Finalmente siempre se llama al final.

cuando lo intentas, ejecuta algún código, si algo sucede en el intento, entonces catch detectará esa excepción y podrías imprimir algunos mensajes o lanzar un error, y finalmente se ejecutará el bloqueo.

Por último, normalmente se usa cuando se realizan limpiezas, por ejemplo, si usa un escáner en Java, probablemente debería cerrar el escáner, ya que provoca otros problemas, como no poder abrir algún archivo.

2
Rubin Luitel

finalmente, el bloque se ejecuta siempre, incluso si pones una declaración de retorno en el bloque try. El bloque finally se ejecutará antes de la declaración de retorno.

2
Sabrina