Envolvendo uma exceção

3. Exceções de empacotamento

As exceções checadas pareciam legais na teoria, mas acabaram se tornando uma grande frustração na prática.

Suponha que você tenha um método super popular em seu projeto. Ele é chamado de centenas de lugares em seu programa. E você decide adicionar uma nova exceção verificada a ele. E pode ser que essa exceção verificada seja realmente importante e tão especial que apenas o main()método saiba o que fazer se for pego.

Isso significa que você terá que adicionar a exceção verificada à throwscláusula de cada método que chama seu método superpopular . Assim como na throwscláusula de todos os métodos que chamam esses métodos. E dos métodos que chamam esses métodos.

Como resultado, as throwscláusulas de metade dos métodos do projeto recebem uma nova exceção verificada . E é claro que seu projeto é coberto por testes e agora os testes não compilam. E agora você também precisa editar as cláusulas throws em seus testes.

E então todo o seu código (todas as alterações em centenas de arquivos) terá que ser revisado por outros programadores. E neste ponto nos perguntamos por que fizemos tantas mudanças sangrentas no projeto? Dia (s?) de trabalho e testes quebrados - tudo para adicionar uma exceção verificada ?

E, claro, ainda existem problemas relacionados à herança e substituição de métodos. Os problemas que vêm das exceções verificadas são muito maiores do que o benefício. O resultado final é que agora poucas pessoas os amam e poucas pessoas os usam.

No entanto, ainda há muito código (incluindo o código da biblioteca Java padrão) que contém essas exceções verificadas . O que fazer com eles? Não podemos ignorá-los e não sabemos como lidar com eles.

Os programadores Java propuseram agrupar as exceções verificadas em arquivos RuntimeException. Em outras palavras, capture todas as exceções verificadas e, em seguida, crie exceções não verificadasRuntimeException (por exemplo, ) e lance-as. Fazendo isso fica mais ou menos assim:

try
{
   // Code where a checked exception might occur
}
catch(Exception exp)
{
   throw new RuntimeException(exp);
}

Não é uma solução muito bonita, mas não há nada de criminoso aqui: a exceção foi simplesmente colocada dentro de um arquivo RuntimeException.

Se desejar, você pode recuperá-lo facilmente de lá. Exemplo:

try
{
   // Code where we wrap the checked exception
   // in a RuntimeException
}
catch(RuntimeException e)
{
   Throwable cause = e.getCause();
   if (cause instanceof Exception)
   {
      Exception exp = (Exception) cause;
      // Exception handling code goes here
   }
}