Fallar rápido, finalmente, la cláusula en Java

Question

Es allí una manera de detectar, desde dentro de la cláusula finally, que es una excepción en el proceso de ser lanzado?

Véase el siguiente ejemplo:

try {
    // code that may or may not throw an exception
} finally {
    SomeCleanupFunctionThatThrows();
    // if currently executing an exception, exit the program,
    // otherwise just let the exception thrown by the function
    // above propagate
}

o es ignorar una de las excepciones, la única cosa que usted puede hacer?

En C++ no te permiten incluso ignorar una de las excepciones y solo llamadas terminate().La mayoría de los otros lenguajes que utilizan las mismas reglas de java.

Answer 1

Establecer una variable de indicador, a continuación, comprobar que en la cláusula finally, así:

boolean exceptionThrown = true;
try {
   mightThrowAnException();
   exceptionThrown = false;
} finally {
   if (exceptionThrown) {
      // Whatever you want to do
   }
}

Answer 2

Si usted se encuentra haciendo esto, entonces usted podría tener un problema con su diseño.La idea de un "finalmente" bloque que desea hacer algo, independientemente de cómo el método de las salidas.Me parece que usted no necesita un bloque finally en absoluto, y sólo debe utilizar los bloques try-catch:

try {
   doSomethingDangerous(); // can throw exception
   onSuccess();
} catch (Exception ex) {
   onFailure();
}

Answer 3

Si una función de lanza y desea capturar la excepción, usted tendrá que ajustar la función de la en un bloque try, es la forma más segura.Así que en tu ejemplo:

try {
    // ...
} finally {
    try {
        SomeCleanupFunctionThatThrows();
    } catch(Throwable t) { //or catch whatever you want here
        // exception handling code, or just ignore it
    }
}

Answer 4

Qué quiere decir que usted desea que el bloque finally para actuar de forma diferente dependiendo de si el bloque try se completó correctamente?

Si es así, siempre se puede hacer algo como:

boolean exceptionThrown = false;
try {
    // ...
} catch(Throwable t) {
    exceptionThrown = true;
    // ...
} finally {
    try {
        SomeCleanupFunctionThatThrows();
    } catch(Throwable t) { 
        if(exceptionThrown) ...
    }
}

Eso es bastante complicado, aunque...usted puede ser que desee pensar de una forma de reestructurar el código para hacer esto innecesario.

Answer 5

No, no lo creo así.El bloque catch se ejecuta hasta el final antes de que el bloque finally.

try {
    // code that may or may not throw an exception
} catch {
// catch block must exist.
finally {
    SomeCleanupFunctionThatThrows();
// this portion is ran after catch block finishes
}

De lo contrario, usted puede agregar un sincronizar() objeto de que el código de excepción va a usar, que se puede comprobar en el bloque finally, que ayudan a identificar si en un hilo separado está ejecutando una excepción.