Não é uma boa prática lidar com exceções de tempo de execução no código?

Estou trabalhando em um aplicativo Java e vejo que as exceções de tempo de execução são tratadas em muitos lugares. Por exemplo,

try {
    // do something
} catch(NullPointerException e) {
    return null;
}

Minhas perguntas são: quando é uma boa prática lidar com exceções de tempo de execução? Quando as exceções devem ser deixadas sem tratamento?

Depende.

Por exemplo, Integer#parseIntlança NumberFormatException(que é um RTE) se a sequência fornecida não puder ser analisada. Mas certamente você não quer que seu aplicativo falhe apenas porque o usuário escreveu "x" em um campo de texto que era para números inteiros? E como você sabe se a string pode ser analisada, a menos que você tente analisá-la primeiro? Portanto, neste caso, o RTE é apenas um sinal de erro que deve causar algum tipo de mensagem de erro. Pode-se argumentar que deve ser uma exceção verificada, mas o que você pode fazer - não é.

NullPointerExceptions geralmente são o sinal de uma verificação nula ausente. Portanto, em vez de capturá-lo dessa maneira, você deve adicionar a verificação nula apropriada para garantir que não lança a exceção.

Mas, às vezes, é apropriado lidar com RunTimeExceptions. Por exemplo, quando você não pode modificar o código para adicionar a verificação nula no local apropriado ou quando a exceção é algo diferente de uma NullPointerException.

Seu exemplo de como lidar com exceções é terrível. Com isso, você perde o rastreamento da pilha e informações precisas sobre o problema. E você realmente não está resolvendo isso, pois provavelmente disparará outra NullPointerException em um local diferente e obterá informações enganosas sobre o que aconteceu e como resolvê-lo.

Eu trato de exceções esperadas onde eu as espero. (Como erros de leitura / gravação de banco de dados). Exceções inesperadas, eu borbulha. Em outro lugar, pode estar esperando a exceção e ter a lógica para isso.

Exceções devem ser exatamente isso ... exceções. A melhor prática ao usar exceções é usá-las para cobrir a situação em que algo contrário ao que você espera que aconteça. O exemplo clássico é o FileNotFoundException que é lançado quando um arquivo simplesmente não existe. Se você estiver testando a existência do arquivo, use File.exists (), já que está simplesmente cutucando com um bastão de 10 pés para ver se bate em alguma coisa.

Tecnicamente, você pode obter os mesmos resultados cercando-o em uma tentativa de captura e usando o arquivo como se ele existisse, mas A) as exceções geralmente são caras em termos de recursos e B) os programadores presumem que você quisesse que o arquivo existisse se existisse. em uma tentativa de captura, o que aumenta a confusão geral de um programa.

Existem muitas situações nas quais escreverei um método que busca algum valor em um banco de dados. Milhares de coisas podem dar errado e, vendo como eu só preciso de um pequeno pedaço de informação, é inconveniente cercar a chamada com uma lista de captura de tentativa que contém 5 exceções diferentes. Então, eu vou pegar exceções no método de busca. Se algo der errado, tomo a ação apropriada para fechar a conexão com o banco de dados ou outros enfeites na cláusula finally e retorno nulo. Essa é uma boa prática, não apenas porque simplifica seu código, mas também porque "null" envia a mesma mensagem que você poderia ter recebido de uma exceção ... de que algo não saiu como o planejado. Gerencie detalhes de exceção no método de busca, mas gerencie o que fazer quando as coisas não acontecerem

Por exemplo:

Integer getUserCount() {
   Integer result = null;
   try {
      // Attempt to open database and retrieve data
   } catch (TimeoutException e) {
      logger.error("Got a watch?");
   } catch (MissingDatabaseException e) {
      logger.error("What are you smoking?");
   } catch (PermissionsToReadException e) {
      logger.error("Did you *really* think you were getting away with that?");
   } catch (PressedSendButtonToHardException e) {
      logger.error("Seriously.. just back away from the computer... slowly..");
   } catch (WTFException e) {
      logger.error("You're on your own with this one.. I don't even know what happened..");
   } finally {
      // Close connections and whatnot
   }
   return result;
}

void doStuff() {
   Integer result = getUserCount();
   if(result != null) {
       // Went as planned..
   }
}

Sim, você está manipulando corretamente as exceções de tempo de execução não é uma boa prática.