Tratamento de exceções em Java: desvendando a ambigüidade

Em um cenário intrigante de tratamento de exceções Java, uma pergunta universitária apresentou o seguinte trecho de código:

// 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();
        }
    }
}

A pergunta solicitada para sua saída e a resposta fornecida foi "13Exception no thread principal MyExc2". No entanto, a resposta correta é "132Exception no thread principal MyExc1".

Esclarecendo a ambigüidade

Para decifrar esse quebra-cabeça, é essencial entender a precedência das exceções:

• Princípio: Quando uma nova exceção é lançada dentro de um bloco catch ou finalmente, a exceção atual que está sendo tratada é abortada.

• Consequências :

  • A propagação da exceção atual é interrompida.
  • A nova exceção se torna a exceção de propagação.
  • A nova exceção desenrola a pilha normalmente, encontrando qualquer captura aplicável ou blocos finalmente.

Refazendo a execução

Aplicando este princípio ao código:

1. Execução inicial:

   • Linha 13: MyExc1 é lançada no bloco try de q().
   • Linha 18: A MyExc1 é capturado no bloco catch de q().
   • Linha 21: A linha 21 é executada (imprime 3).

2. Catch Block Exceção:

   • Linha 19: MyExc2 é lançada no bloco catch de main().
   • Linha 22: MyExc2 aborta a propagação de MyExc1.
   • Linha 19: MyExc2 começa a desenrolar a pilha.

3. A execução é retomada no bloco Try do Main:

   • Linha 15 : A linha 15 é executada (imprime 2).
   • Linha 16: MyExc1 é lançada no bloco final de main().
   • Linha 16: MyExc1 aborta a propagação de MyExc2.
   • Linha 16: MyExc1 começa a desenrolar a pilha (e ainda está sujeito ao bloco final do main).

4. Finally Block Exception:

   • Linha 23: A exceção é lançada no bloco final de main().
   • Linha 23: A exceção anula a propagação de MyExc1.
   • Linha 23: A exceção começa a se desenrolar aumente a pilha. do método principal é o MyExc1 lançado na linha 16. O MyExc2 lançado na linha 19 é abortado quando MyExc1 é lançado na linha 16.