Gestion des exceptions en Java : lever l'ambiguïté

Dans un scénario déroutant de gestion des exceptions Java, une question universitaire présentait l'extrait de code suivant :

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

// Main Class
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 sa sortie et la réponse fournie était "13Exception dans le thread principal MyExc2". Cependant, la bonne réponse est "132Exception dans le thread principal MyExc1".

Clarifier l'ambiguïté

Pour déchiffrer ce casse-tête, il est essentiel de comprendre la préséance des exceptions :

• Principe : Lorsqu'une nouvelle exception est levée dans un bloc catch ou enfin, l'exception en cours de traitement est abandonnée.

• Conséquences :

  • La propagation de l'exception actuelle est interrompue.
  • La nouvelle exception devient l'exception de propagation.
  • La nouvelle exception déroule la pile normalement, rencontrer un catch ou un bloc final applicable.

Retracer l'exécution

Application de ce principe au code :

1. Exécution initiale :

   • Ligne 13 : MyExc1 est lancé dans le bloc try de q().
   • Ligne 18 : Le MyExc1 est capturé dans le bloc catch de q().
   • Ligne 21 : la ligne 21 est exécutée (imprime 3).

2. Catch Block Exception :

   • Ligne 19 : MyExc2 est lancé dans le bloc catch de main().
   • Ligne 22 : MyExc2 abandonne la propagation de MyExc1.
   • Ligne 19 : MyExc2 commence à dérouler la pile.

3. L'exécution reprend dans le bloc Try de Main :

   • Ligne 15 : La ligne 15 est exécutée (imprime 2).
   • Ligne 16 : MyExc1 est lancé dans le bloc final de main().
   • Ligne 16 : MyExc1 abandonne la propagation de MyExc2.
   • Ligne 16 : MyExc1 commence à dérouler la pile (et est toujours soumis au bloc final de main).

4. Finally Block Exception :

   • Ligne 23 : une exception est levée dans le bloc final de main().
   • Ligne 23 : l'exception annule la propagation de MyExc1.
   • Ligne 23 : l'exception commence à se dérouler la pile.

Sortie :

La sortie finale est "132Exception dans le thread principal MyExc1" car l'exception qui se propage de la méthode principale est le MyExc1 lancé à la ligne 16. Le MyExc2 lancé à la ligne 19 est abandonné lorsque MyExc1 est lancé à la ligne 16.