¿No es una buena práctica manejar las excepciones de tiempo de ejecución en el código?

Estoy trabajando en una aplicación Java, y veo que las excepciones de tiempo de ejecución se manejan en muchos lugares. Por ejemplo,

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

Mi pregunta es, ¿cuándo es una buena práctica manejar las excepciones de tiempo de ejecución? ¿Cuándo deben dejarse de lado las excepciones?

Depende.

Por ejemplo, Integer#parseIntthrows NumberFormatException(que es un RTE) si la cadena proporcionada no se puede analizar. ¿Pero seguramente no desea que su aplicación se bloquee solo porque el usuario escribió "x" en un campo de texto que era para enteros? ¿Y cómo sabes si la cadena se puede analizar, a menos que intentes analizarla primero? Entonces, en este caso, el RTE es solo una señal de error que debería causar algún tipo de mensaje de error. Se podría argumentar que debería ser una excepción marcada, pero ¿qué puede hacer? No lo es.

Las excepciones de puntero nulo suelen ser el signo de una comprobación nula faltante. Por lo tanto, en lugar de atraparlo así, debe agregar la verificación nula adecuada para asegurarse de no lanzar la excepción.

Pero a veces, es apropiado manejar RunTimeExceptions. Por ejemplo, cuando no puede modificar el código para agregar la verificación nula en el lugar apropiado, o cuando la excepción no es una excepción NullPointerException.

Su ejemplo de manejo de excepciones es terrible. Al hacerlo, pierde el rastro de la pila y la información precisa sobre el problema. Y en realidad no lo está resolviendo, ya que probablemente desencadenará otra NullPointerException en un lugar diferente y obtendrá información engañosa sobre lo que sucedió y cómo resolverlo.

Manejo las excepciones esperadas donde las espero. (Como errores de lectura / escritura de DB). Excepciones inesperadas burbujeo. En otro lugar puede estar esperando la excepción y tener la lógica para ello.

Las excepciones deberían ser solo eso ... excepciones. La mejor práctica cuando se usan excepciones es usarlas para cubrir la situación en la que sucede algo contrario a lo que cabría esperar. El ejemplo clásico es la FileNotFoundException que se produce cuando un archivo simplemente no está allí. Si está probando la existencia del archivo, entonces usa File.exists () ya que simplemente está presionando con un palo de 10 pies para ver si golpea algo.

Técnicamente, podría lograr los mismos resultados al rodearlo en un intento de captura y usar el archivo como si existiera, pero A) las excepciones son generalmente costosas en cuanto a recursos y B) los programadores van a asumir que usted quiso decir que el archivo existía si era en un intento de captura, que se suma a la confusión general de un programa.

Hay muchas situaciones en las que escribiré un método que obtiene algún valor de una base de datos. Mil cosas podrían salir mal, y viendo que solo necesito una pequeña información, es inconveniente rodear la llamada con una lista de prueba que contiene 5 excepciones diferentes. Entonces, atraparé excepciones en el método fetch. Si algo sale mal, tomo cualquier acción apropiada para cerrar la conexión de la base de datos o cualquier otra cosa en la cláusula final y devuelvo nulo. Esta es una buena práctica no solo porque simplifica su código sino también porque "nulo" envía el mismo mensaje que podría haber recibido de una excepción ... de que algo no salió según lo planeado. Administre detalles de excepción en el método de búsqueda, pero administre qué hacer cuando las cosas no '

Por ejemplo:

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í, está manejando correctamente las excepciones de tiempo de ejecución no es una buena práctica. La razón es que se considera costoso / requiere mucha memoria.