Gestion des exceptions dans les clauses Catch et Enfin

Lorsque vous traitez la gestion des exceptions en Java, il est crucial de comprendre l'interaction entre les clauses catch etfinal. . Prenons l'exemple suivant fourni pour un devoir universitaire :

class MyExc1 extends Exception {}
class MyExc2 extends Exception {}
class MyExc3 extends MyExc2 {}

public class C1 {
    public static void main(String[] args) throws Exception {
        try {
            System.out.print(1);
            q();
        }
        catch (Exception i) {
            throw new MyExc2();
        }
        finally {
            System.out.print(2);
            throw new MyExc1();
        }
    }

    static void q() throws Exception {
        try {
            throw new MyExc1();
        }
        catch (Exception y) {
        }
        finally {
            System.out.print(3);
            throw new Exception();
        }
    }
}

La question demandait la sortie de ce code. Même si certains ont peut-être répondu « 13Exception dans le fil principal MyExc2 », la bonne réponse est « 132Exception dans le fil principal MyExc1 ».

Pourquoi MyExc2 disparaît

La clé pour comprendre le résultat correct réside dans le comportement des clauses catch et enfin. Lorsqu'une exception est levée dans un bloc catch ou final, cela a des implications significatives sur le flux. Voici une répartition :

• Exception dans le bloc catch : Si une nouvelle exception est levée dans un bloc catch (comme vu avec throw new MyExc2() ci-dessus), l'exception d'origine est "avorté." Le chemin d'exécution actuel reste incomplet et la nouvelle exception prend le relais comme celle qui se propage vers l'extérieur.

• Exception dans le bloc final : De même, si une nouvelle exception est levée un bloc final, l'exception d'origine est également abandonnée. Cependant, il y a un point crucial à noter :

  • Bloc final du bloc catch : Si la nouvelle exception est levée dans le bloc final d'un bloc catch, elle sera toujours soumise au bloc final de ce catch. enfin bloquer, le cas échéant.

Traçage des exceptions

En traçant l'exécution sur la base de ces principes, nous pouvons voir que :

1. Le bloc try dans main imprime "1" et appelle q().
2. À l'intérieur de q(), le bloc try lance un MyExc1.
3. Le bloc catch dans q() gère l'exception en silence.
4. Le bloc final dans q() imprime "3" et lève une exception.

5. Bloc Catch dans main :

   • Le MyExc2 est lancé dans ce bloc, abandonnant le MyExc1 d'origine.
   • Cependant, le bloc catch a un bloc final qui s'exécute toujours.

6. Enfin bloquer dans main :

   • Le MyExc1 est lancé dans ce bloc, abandonnant le MyExc2.

Par conséquent, la sortie correcte est « 132Exception dans le thread principal MyExc1 ». L'exception MyExc2 est "oubliée" car une nouvelle exception (MyExc1) est levée dans le bloc final du bloc catch qui gérait MyExc2.