Non è una buona pratica gestire le eccezioni di runtime nel codice?

Sto lavorando su un'applicazione Java e vedo che le eccezioni di runtime sono gestite in molti punti. Per esempio,

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

La mia domanda è: quando è una buona pratica gestire le eccezioni di runtime? Quando dovrebbero essere gestite le eccezioni?

Dipende.

Ad esempio, Integer#parseIntgenera NumberFormatException(che è un RTE) se la stringa fornita non può essere analizzata. Ma sicuramente non vuoi che la tua app vada in crash solo perché l'utente ha scritto "x" in un campo di testo che era per numeri interi? E come fai a sapere se la stringa può essere analizzata, a meno che non provi prima ad analizzarla? Quindi, in questo caso, l'RTE è solo un segnale di errore che dovrebbe causare qualche tipo di messaggio di errore. Si potrebbe sostenere che dovrebbe essere un'eccezione controllata, ma cosa si può fare - non lo è.

NullPointerExceptions sono in genere il segno di un controllo null mancante. Quindi, invece di catturarlo in questo modo, è necessario aggiungere l'appropriato controllo null per essere sicuri di non generare l'eccezione.

Ma a volte, è opportuno gestire RunTimeExceptions. Ad esempio, quando non è possibile modificare il codice per aggiungere il controllo null nel punto appropriato o quando l'eccezione è diversa da NullPointerException.

Il tuo esempio di gestione delle eccezioni è terribile. In questo modo, perdi la traccia dello stack e le informazioni precise sul problema. E in realtà non lo stai risolvendo poiché probabilmente innescerai un'altra NullPointerException in un posto diverso e otterrai informazioni fuorvianti su ciò che è accaduto e su come risolverlo.

Gestisco le eccezioni previste dove mi aspetto. (Come errori di lettura / scrittura DB). Eccezioni inaspettate Mi alzo. Da qualche altra parte potrebbe aspettarsi l'eccezione e avere la logica per essa.

Le eccezioni dovrebbero essere proprio queste ... eccezioni. La migliore pratica quando si usano le eccezioni è usarle per coprire la situazione in cui accade qualcosa di contrario a ciò che ci si aspetta che accada. L'esempio classico è FileNotFoundException che viene generato quando un file semplicemente non è presente. Se stai testando l'esistenza del file, allora usi File.exists () poiché stai semplicemente spingendo con un bastone da 10 piedi per vedere se colpisci qualcosa.

Potresti ottenere tecnicamente gli stessi risultati circondandolo in un tentativo di prova e usando il file come se esistesse, ma A) le eccezioni sono generalmente costose dal punto di vista delle risorse e B) i programmatori supporranno che intendevi che il file esistesse se lo fosse in una prova, che aggiunge alla confusione generale di un programma.

Ci sono molte situazioni in cui scriverò un metodo che recupera un valore da un database. Mille cose potrebbero andare storte e, visto che ho solo bisogno di una piccola informazione, è scomodo circondare la chiamata con un elenco di prova che contiene 5 diverse eccezioni. Quindi, prenderò delle eccezioni nel metodo di recupero. Se qualcosa va storto, intraprendo qualsiasi azione appropriata per chiudere la connessione al database o quant'altro nella clausola finally e restituire null. Questa è una buona pratica non solo perché semplifica il tuo codice ma anche perché "null" invia lo stesso messaggio che avresti potuto ottenere da un'eccezione ... che qualcosa non è andato come previsto. Gestisci le specifiche delle eccezioni nel metodo di recupero, ma gestisci cosa fare quando le cose non vanno

Per esempio:

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..
   }
}

sì, stai gestendo correttamente le eccezioni del tempo di esecuzione non è una buona pratica. Il motivo è che è considerato costoso / ad alta memoria.