Questão de Programação — Linguagens de programação — FGV 2026

Controle de fluxo em Java: break, continue e rótulos

Gabarito: letra B. Para interromper o laço interno e avançar imediatamente para a próxima iteração do laço externo, a instrução correta é continue outerLoop, onde outerLoop é o rótulo atribuído ao laço externo. O continue sozinho apenas pularia para a próxima iteração do laço interno, e o break encerraria apenas o laço interno, não atendendo ao requisito de avançar para a próxima conta.

Em Java, os comandos de controle de fluxo break e continue podem ser usados com rótulos para controlar laços aninhados. Um rótulo é um identificador seguido de dois pontos (:), colocado antes de um laço. Quando continue é seguido de um rótulo, ele interrompe a iteração atual do laço rotulado e continua com a próxima iteração desse laço. Isso é exatamente o que o requisito pede: ao encontrar uma transação inválida, ignorar a transação atual e avançar para a próxima conta, ou seja, para a próxima iteração do laço externo.

Vamos entender cada comando:

• break: encerra imediatamente o laço mais interno em que está. Se usado sem rótulo, interrompe apenas o laço atual. Com rótulo, interrompe o laço rotulado.

• continue: pula para a próxima iteração do laço mais interno. Sem rótulo, afeta apenas o laço atual. Com rótulo, pula para a próxima iteração do laço rotulado.

• return: encerra a execução do método atual, retornando ao chamador. Não é apropriado para controle de laços, pois interromperia todo o processamento.

• throw new Exception(): lança uma exceção, que pode ser capturada por um bloco try-catch. Não é uma forma de controle de fluxo normal para pular iterações.

A pegadinha aqui é que muitos candidatos confundem break com continue ou esquecem que continue pode ser usado com rótulos. O break encerraria o laço interno, mas o requisito é continuar o laço externo, não encerrá-lo. O continue sem rótulo apenas pularia para a próxima transação da mesma conta, não avançando para a próxima conta.

Na prática, o código seria algo como:

outerLoop:
for (Conta conta : contas) {
    for (Transacao transacao : conta.getTransacoes()) {
        if (transacao.getValor() < 0) {
            continue outerLoop; // avança para a próxima conta
        }
        // processa transação válida
    }
}

Assim, ao encontrar uma transação inválida, o continue outerLoop faz o controle pular para a próxima iteração do laço externo, ignorando as transações restantes da conta atual.

Alternativa A — ❌ Incorreta

O break sem rótulo interrompe apenas o laço interno, encerrando o processamento das transações da conta atual, mas não avança para a próxima conta — ele sai do laço interno e continua no laço externo na mesma iteração, ou seja, passaria para a próxima conta, mas de forma diferente: o laço externo continuaria normalmente, mas o laço interno seria encerrado. Na verdade, break sem rótulo encerraria o laço interno e o laço externo continuaria para a próxima conta, mas isso não é o mesmo que continue outerLoop, pois break não pula a iteração atual do laço externo — ele apenas sai do laço interno. O efeito prático seria similar, mas a semântica é diferente: break encerra o laço interno, enquanto continue outerLoop pula a iteração atual do laço externo. No entanto, o requisito é "avançar imediatamente para a próxima conta", o que break faria, mas não de forma explícita e poderia causar confusão se houvesse código após o laço interno. A alternativa está incorreta porque break não é a instrução que atende ao requisito de "continuar iterando o laço externo" — ele encerra o laço interno, não pula a iteração do externo.

Alternativa B — ✅ Correta ⟵ GABARITO

continue outerLoop é a instrução correta. Ela faz o controle pular para a próxima iteração do laço rotulado outerLoop, que é o laço externo. Isso atende exatamente ao requisito: ao encontrar uma transação inválida, a transação atual é ignorada e o laço externo avança para a próxima conta, sem continuar iterando o laço interno.

Alternativa C — ❌ Incorreta

return encerraria a execução do método inteiro, interrompendo todo o processamento das contas e transações. Isso não atende ao requisito, pois o sistema deve continuar processando as próximas contas.

Alternativa D — ❌ Incorreta

throw new Exception() lançaria uma exceção, que precisaria ser capturada e tratada. Isso interromperia o fluxo normal e não é uma forma adequada de simplesmente ignorar uma transação e continuar o processamento. Além disso, lançar exceções para controle de fluxo é uma má prática.

Alternativa E — ❌ Incorreta

continue sem rótulo pula para a próxima iteração do laço mais interno, ou seja, para a próxima transação da mesma conta. Isso não atende ao requisito, pois o laço externo não avança para a próxima conta — ele continuaria processando as transações restantes da conta atual.

Gabarito: letra B