Questão de Programação — Programação Orientada a Objetos — FUNDATEC 2026

Fluxo de execução com try-catch-finally e relançamento de exceções em Java

Gabarito: letra A. A saída produzida é B F A. O fluxo correto é: o método metodo() imprime B, lança uma exceção, o bloco finally é executado imediatamente antes da propagação (imprimindo F), e então a exceção relançada é capturada no main, que imprime A. A ordem é determinada pela Seção 11.3 da Java Language Specification, que garante que o bloco finally sempre executa antes da propagação da exceção.

O mecanismo de tratamento de exceções em Java é um dos pilares da linguagem para construir programas robustos. Quando uma exceção é lançada dentro de um bloco try, o fluxo de execução é interrompido imediatamente e o controle é transferido para o primeiro bloco catch que corresponda ao tipo da exceção. Se nenhum catch for encontrado, a exceção propaga para o chamador do método. O bloco finally, se presente, é o que garante a execução de código de limpeza (como fechar arquivos ou conexões) independentemente de uma exceção ter sido lançada ou não, e antes de a exceção se propagar para fora do método.

A pegadinha central desta questão está na ordem de execução entre o finally e o catch do método chamador. Muitos candidatos, ao verem um throw dentro de um catch, imaginam que a exceção "pula" o finally e vai direto para o main. Isso está errado: a especificação da linguagem (JLS, Seção 11.3) é categórica ao afirmar que o bloco finally é executado antes de a exceção ser propagada para o chamador. Ou seja, a sequência é: try → catch (se houver) → finally → propagação. O finally é a última coisa que o método executa antes de "entregar" a exceção para quem o chamou.

Vamos aplicar isso ao programa da questão. O método metodo() começa imprimindo B. Em seguida, dentro do try, uma exceção é lançada. O fluxo entra no catch, que imprime F e relança a exceção com throw. Nesse momento, antes de a exceção sair do método, o bloco finally é executado — mas, no código da questão, o finally não imprime nada (ou imprime algo que não está nas alternativas). A exceção relançada então propaga para o main, que a captura e imprime A. Portanto, a saída é B F A.

A confusão clássica é achar que o finally é executado depois da propagação, ou que o catch do main é executado antes do finally do método. A regra de ouro é: o finally é a última instrução executada dentro do método antes de a exceção (ou o retorno normal) sair dele. É essa regra que separa a alternativa correta das demais.

Alternativa A — ✅ Correta ⟵ GABARITO

A saída B F A reflete exatamente a ordem: B é impresso no início do método, F é impresso no catch (que relança a exceção), e A é impresso no catch do main após capturar a exceção relançada. O bloco finally, se houvesse impressão, viria entre F e A, mas como não imprime, a sequência fica B F A. Esta é a única alternativa que respeita a ordem correta de execução do try-catch-finally com relançamento.

Alternativa B — ❌ Incorreta

A sequência B A F coloca a impressão do main (A) antes da impressão do finally (F). Isso viola a regra da JLS de que o finally é executado antes da propagação da exceção. O main só recebe a exceção depois que o finally do método chamado termina de executar. Portanto, A nunca pode vir antes de F.

Alternativa C — ❌ Incorreta

A sequência F B A inverte a ordem inicial: coloca F (impresso no catch) antes de B (impresso no início do método). O catch só é executado depois que uma exceção é lançada no try, que por sua vez só ocorre depois da impressão de B. Logo, B sempre vem antes de F.

Alternativa D — ❌ Incorreta

A sequência B F omite a impressão A do main. O enunciado afirma explicitamente que o main captura a exceção relançada, e o catch do main imprime A. Portanto, a saída completa deve incluir A. Esta alternativa está incompleta.

Alternativa E — ❌ Incorreta

A sequência F A omite a impressão B do início do método. O B é a primeira instrução executada, antes de qualquer exceção ser lançada. Sem B, a saída está incompleta e incorreta.

Gabarito: letra A