java - Trata de atrapar, finalmente con retorno después de que

return try-catch

Question

Sé cómo probar, capturar y finalmente trabajar (en su mayor parte), pero tengo una cosa que me preguntaba: ¿qué sucede con una declaración de retorno después de un intento-captura-finalmente, mientras que ya tuvimos un retorno en el intento (o captura) )?

Por ejemplo:

public boolean someMethod(){
    boolean finished = false;
    try{
        // do something
        return true;
    }
    catch(someException e){
        // do something
    }
    finally{
        // do something
    }
    return finished;
}

Digamos que nada salió mal en el intento, por lo que volvimos verdad. Luego iremos al final donde haremos algo como cerrar una conexión, ¿y luego?

¿Se detendrá el método después de que hicimos algunas cosas en el final (por lo que el método se volvió verdadero en el intento), o continuará el método después de que finalmente vuelva a terminar, lo que es falso?

Gracias de antemano por las respuestas.

Answer 1

Definitivamente, el código dentro de try se ejecutará ... pero cuando alcanza la instrucción return ... se moverá al bloque finally sin ejecutar la instrucción return en el bloque try .. y luego se ejecutará el código de finally y luego la declaración return de el intento lo ejecutará.

Answer 2

El hecho de que se ejecute finalmente el bloque no hace que el programa olvide que usted regresó. Si todo va bien, el código después del bloque finally no se ejecutará.

Aquí hay un ejemplo que lo aclara:

public class Main {

    public static void main(String[] args) {
        System.out.println("Normal: " + testNormal());
        System.out.println("Exception: " + testException());
    }

    public static int testNormal() {
        try {
            // no exception
            return 0;
        } catch (Exception e) {
            System.out.println("[normal] Exception caught");
        } finally {
            System.out.println("[normal] Finally");
        }
        System.out.println("[normal] Rest of code");
        return -1;
    }

    public static int testException() {
        try {
            throw new Exception();
        } catch (Exception e) {
            System.out.println("[except] Exception caught");
        } finally {
            System.out.println("[except] Finally");
        }
        System.out.println("[except] Rest of code");
        return -1;
    }

}

Salida:

[normal] Finally
Normal: 0
[except] Exception caught
[except] Finally
[except] Rest of code
Exception: -1

Answer 3

En ese caso, el código que se encuentra dentro de la ejecución final se ejecuta pero la otra devolución se omite cuando no hay excepciones. También puedes ver esto por ti mismo al registrar algo :)

También vea esto con respecto a System.exit : ¿Cómo funciona System.exit () de Java con los bloques try / catch / finally?

Y vea cómo regresa de un finalmente: Regresando de un bloque finalmente en Java

Answer 4

Si todo va bien, el retorno dentro del try se ejecuta después de ejecutar el bloque finally .

Si algo sale mal dentro del try , la exception se captura y ejecuta y, finally , se ejecuta el bloqueo y luego se ejecuta la devolución posterior.

Answer 5

public int Demo1()
    {
        try{
            System.out.println("TRY");
            throw new Exception();
            }catch(Exception e){
                System.out.println("CATCH");
            }finally{
                System.out.println("FINALLY");
            }return 0;

    }

La salida de llamada a este método es así.

TRY
CATCH
FINALLY
0

Significa considerar Try{}catch{}finally{} como secuencia de instrucciones ejecutadas una por una en este caso particular. Y que el control va para volver.