La clause fast fast finally dans Java

Question

Existe-t-il un moyen de détecter, à partir de la clause finally, qu'une exception est en cours de lancement?

-à-dire:

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 
} 

ou ignore l'une des exceptions, la seule chose que vous pouvez faire. En C++, il ne vous permet même pas d'ignorer l'une des exceptions et d'appeler simplement terminate(). La plupart des autres langues utilisent les mêmes règles que Java.

Answer 1

Définir une variable de drapeau, puis de vérifier dans la clause finally, comme suit:

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

Answer 2

Non, je ne le crois pas. Le bloc catch sera exécuté avant le bloc 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 
} 

Sinon, vous pouvez ajouter un objet Synchronize() que le code d'exception utilisera, que vous pouvez vérifier dans le bloc enfin, qui vous aidera à déterminer si dans un thread séparé vous exécutez une exception.

Answer 3

Si une fonction se déclenche et que vous souhaitez intercepter l'exception, vous devez envelopper la fonction dans un bloc try, c'est la manière la plus sûre. Donc, dans votre exemple:

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

Answer 4

Voulez-vous dire que vous voulez que le bloc finally d'agir différemment selon que le bloc try est-il terminé avec succès?

Si oui, vous pouvez toujours faire quelque chose comme:

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

qui devient assez alambiquée, mais ... vous pouvez penser à une façon de restructurer votre code pour faire cela inutile.

Answer 5

Si vous vous trouvez en faisant cela, alors vous pourriez avoir un problème avec votre conception. L'idée d'un bloc "finally" est que vous voulez que quelque chose soit fait indépendamment de la façon dont la méthode se termine. Il me semble que vous n'avez pas besoin d'un bloc finally, et vous devriez utiliser les blocs try-catch:

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