Assegurando a conclusão das instruções de comutação

É uma boa prática assegurar que cada instrução de comutação deva ser concluída no sentido de que cada execução no tempo de execução encontrará uma ramificação adequada. Esta é, na verdade, uma tarefa não trivial considerando o seguinte:

Além disso, o JLS obriga uma análise de fluxo para instruções de comutação numérica que podem levar a erros de tempo de compilação inesperados:

    enum Colors { RED, GREEN, BLUE }
    String colorString(Color c) {
        switch(c) {
            case RED: return "red";
            case GREEN: return "green";
            case BLUE: return "blue";
        }
    }

O compilador responderá:

"Este método deve retornar um resultado do tipo Sequência. Observe que um problema em relação a 'default:' ausente em 'switch' foi suprimido, o que está relacionado talvez a este problema".

Esta mensagem foi projetada para alertar os usuários quanto às diferentes noções de conclusão: a análise do fluxo obrigada pelo JLS considera cada instrução de comutação numérica sem um caso padrão como incompleta, mesmo que liste todas as constantes numéricas (atualmente conhecidas). Isto relaciona-se com instruções de retorno assim como designação definida de variáveis locais ou campos finais em branco. Entretanto, se seguir todas as recomendações abaixo, a mensagem de erro acima nunca ocorrerá.

Consulte as preferências do compilador em relação às opções de configuração individuais para vários níveis de relatório de inconclusão. Em seguida, discutimos os diferentes objetivos de design e políticas e como podem ser verificados usando o compilador Java Eclipse.

Ao usar "default:"

Idealmente, cada instrução de comutação deve ter uma manipulação padrão significativa, que manipula todos os casos que não são explicitamente listados usando a estratégia "always-reasonable". Obviamente, tal estratégia é difícil ou mesmo impossível de localizar em quaisquer casos, mas se puder localizar uma implementação padrão significativa, certamente é a melhor solução.

Recomendação: Ao deixar o compilador avisá-lo sobre cada instrução de comutação que necessita de um caso padrão, você é lembrado de procurar uma boa implementação padrão para cada instrução de comutação.

Se o compilador avisá-lo sobre um caso padrão ausente, mas a coisa razoável a fazer por padrão for apenas não fazer nada, isto pode também valer a pena documentar.

Recomendação: Se "fazer nada" for uma estratégia padrão razoável, você deverá incluir um rótulo padrão: cuja ação seja apenas um comentário explicando que (e por quê) fazer nada está OK neste comutador. Ao fazer isto, você também informa o compilador que simplesmente não se esqueceu do caso padrão.

Se definitivamente nenhuma implementação padrão razoável puder ser localizada, como uma última esperança, é possível evitar que um valor inesperado seja a causa raiz para outros erros de recebimento de dados adicional, por exemplo, você pode querer falhar antecipadamente no tempo de execução.

Recomendação: Se nenhuma implementação padrão razoável puder ser localizada nem "fazer nada" parecer ser uma boa estratégia, inclua um caso padrão: que lança uma exceção e/ou registre o problema.

Cada instrução de comutação deve ser designada a uma das três categorias acima. Isto significa que deixar o compilador avisar sobre cada caso padrão ausente é uma estratégia válida universalmente.

Manipulando todas as constantes numéricas

Ao executar um comutador sobre um valor numérico, pode ser desejável cobrir explicitamente cada constante numérica por uma instrução de caso correspondente.

Recomendação: Se desejar ser avisado sobre instruções de comutação numérica que necessitam de uma instrução de caso para qualquer uma das constantes numéricas, considere ativar a opção Sinalizar mesmo se o caso 'default' existir.

Se não gostar da opção que todos comutadores numéricos devem mencionar todas as constantes numéricas, mas ainda desejar obter o aviso sobre rótulos de caso ausentes para algumas instruções de comutação numéricas, será necessário selecionar a estratégia para cada instrução de comutação numérica individual.

Recomendação: Se o aviso acima for desejável para algumas instruções de comutação, considere ativar o aviso globalmente e identifique as instruções de comutação em que está OK omitir casos para algumas constantes numéricas, porque elas são manipuladas adequadamente pelo caso padrão. Para essas instruções de comutação, use a tag comentário '//$CASES-OMITTED$' para documentar sua decisão:
    String colorString2(Color c) {
        switch(c) {
        case RED: return "red";
        case GREEN: return "green";
            //$CASES-OMITTED$
        default:
        	return "unknown color";
        }
    }

Dica: Se o compilador relatar algo como "A constante numérica BLUE deve ter um rótulo case correspondente neste comutador numérico em Cor", uma correção rápida será oferecida para inserir a tag comentário.

Resumo

As considerações acima mostraram que você obtém a maior parte da ajuda do compilador se ativar todos os avisos opcionais em relação a instruções de comutação incompletas e usar quaisquer casos padrão documentados vazios mais a tag comentários //$CASES-OMITTED$ para marcar as instruções de comutação em que a inconclusão está OK por design. Se seguir essas recomendações, obterá todos os avisos relevantes (ou erros se preferir), quando as ramificações forem omitidas por acidente, incluindo a situação de inclusão tardia de uma ou mais constantes. Todas as exceções desta conclusão máxima serão documentadas no código e não serão mais sinalizadas com um aviso.

Ainda assim o compilador não pode impedir o uso de versões inconsistentes de classe no tempo de execução, portanto uma classe pode ser compilada em relação a uma versão antiga de um tipo numérico, mas no aplicativo em execução, o tipo numérico pode ter mais constantes numéricas. Para essas situações e situações semelhantes, uma implementação padrão "catch-all" apropriada pode levantar exceções de tempo de execução para alertar sobre esta inconsistência e evitar que o erro se propague ainda mais no aplicativo.

Como um valor incluído das configurações estritas do compilador recomendadas acima, a mensagem de erro dúbia sobre uma instrução de retorno ausente mostrada acima (ou mensagens semelhantes sobre variáveis não inicializadas) não ocorrerá mais.