Tratamento de exceções em cláusulas Catch e Finalmente

Ao lidar com o tratamento de exceções em Java, é crucial compreender a interação entre as cláusulas catch e finalmente . Considere o seguinte exemplo fornecido para uma tarefa universitária:

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

A pergunta solicitada para a saída deste código. Embora alguns possam ter respondido "13Exception no thread principal MyExc2", a resposta correta é "132Exception no thread principal MyExc1."

Por que MyExc2 desaparece

A chave para a compreensão a saída correta está no comportamento das cláusulas catch e finalmente. Quando uma exceção é lançada dentro de um bloco catch ou finalmente, isso tem implicações significativas no fluxo. Aqui está um detalhamento:

• Exceção no bloco catch: Se uma nova exceção for lançada em um bloco catch (como visto em throw new MyExc2() acima), a exceção original é "abortado." O caminho de execução atual fica incompleto e a nova exceção assume o controle como aquela que se propaga para fora.

• Exceção no bloco final: Da mesma forma, se uma nova exceção for lançada um bloco final, a exceção original também é abortada. No entanto, há um ponto crucial a ser observado:

  • Bloco final do bloco Catch: Se a nova exceção for lançada no bloco final de um bloco catch, ela ainda estará sujeita a esse bloco catch finalmente bloquear, se houver.

Tracing the Exceptions

Traçando a execução com base nesses princípios, podemos ver que:

1. O bloco try em main imprime "1" e chama q().
2. Dentro de q(), o bloco try lança um MyExc1.
3. O bloco catch em q() trata a exceção silenciosamente.
4. O bloco finalmente em q() imprime "3" e lança uma exceção.

5. Catch bloco em main:

   • O MyExc2 é lançado neste bloco, abortando o MyExc1 original.
   • No entanto, o bloco catch tem um bloco final que ainda é executado.

6. Finalmente bloco principal:

   • O MyExc1 é lançado neste bloco, abortando o MyExc2.

Portanto, a saída correta é "132Exception in thread main MyExc1." A exceção MyExc2 é "esquecida" porque uma nova exceção (MyExc1) é lançada no bloco final do bloco catch que estava manipulando o MyExc2.