Diferencias entre Runtime / Checked / Unchecked / Error / Exception

¿Cuáles son las excepciones de tiempo de ejecución y cuáles son las excepciones controladas / no comprobadas y la diferencia entre error / excepción? ¿Por qué estos muchos tipos? En cambio, Java simplemente puede seguir un diseño simple (simplemente intente / atrape todos los tipos) para manejar una condición anormal en un progtwig.

Throwable está en la cima de todas las excepciones. Debajo de Throwable tienes Error y Excepción. Debajo de Exception tienes RuntimeException.

Java tiene dos tipos de excepciones: marcadas y sin marcar. El comstackdor impone excepciones controladas (debe declararlas en la cláusula throws y capturarlas eventualmente). Las excepciones no verificadas no se aplican para atrapar o declarar en la cláusula throws.

(Parte polémica de la respuesta)

Throwable existe para que haya un padre para todos los tipos de excepción. Nunca debes declarar que arrojas a Throwable y nunca lo atrapes (a menos que realmente realmente sepas lo que estás haciendo).

Existe un error que indica problemas con el entorno de tiempo de ejecución, cosas de las que su progtwig probablemente no pueda recuperarse, como un archivo de clase mal formateado o la VM que se queda sin memoria. No debería detectar un error a menos que realmente sepa lo que está haciendo.

Existe una excepción como la raíz de todos los errores no progtwigdores (vea RuntimeException para la “excepción” a esto), como que no se puede crear un archivo porque el disco está lleno. No debe arrojar, arrojar o atrapar Excepción. Si tiene que atrapar Exception, asegúrese de saber lo que está haciendo.

RuntimeException existe para indicar todos los errores del progtwigdor, como ir más allá del final de una matriz o llamar a un método en un objeto nulo. Estas son las cosas que debe corregir para que no arrojen excepciones: indican que usted, el progtwigdor, arruinó el código. De nuevo, no deberías atrapar estos a menos que sepas lo que estás haciendo.

Como soy un nuevo desarrollador de Java, también he tenido dificultades para distinguir y manejar diferentes tipos de excepciones. Es por eso que he hecho una breve nota sobre este tema, y ​​cada vez que me confundo lo reviso. Aquí está con la imagen de la jerarquía de clase Throwable :
Jerarquía de clase descartable

[imagen cortesía de JavaTpoint ].

Hay tres clases clave para recordar aquí: Throwable , Exception y Error . Entre estas clases, Exception se puede dividir en dos tipos: “Excepción comprobada” y “Excepción no verificada”.

Excepción comprobada:

  • Estas son las clases que se extienden Throwable excepto RuntimeException y Error .
  • También se conocen como excepciones de tiempo de comstackción porque se controlan en tiempo de comstackción, lo que significa que el comstackdor nos obliga a manejarlas con try/catch o indicar en la firma de la función que las throws y obligarnos a tratarlas en la persona que llama.
  • Son problemas recuperables mediante progtwigción que son causados ​​por condiciones inesperadas fuera del control del código (p. Ej. Base de datos inactiva, error de E / S de archivo, entrada incorrecta, etc.).
  • Ejemplo: IOException , SQLException , etc.

Excepción no verificada:

  • Las clases que extienden RuntimeException se conocen como excepciones sin marcar.
  • Las excepciones no verificadas no se verifican en tiempo de comstackción, sino en tiempo de ejecución, de ahí el nombre.
  • También son problemas recuperables mediante progtwigción pero, a diferencia de la excepción comprobada , son causados ​​por fallas en el flujo o la configuración del código.
  • Ejemplo: ArithmeticException , NullPointerException , ArrayIndexOutOfBoundsException , etc.
  • Debido a que son errores de progtwigción, pueden evitarse con una encoding agradable / inteligente. Por ejemplo, “dividir por cero” produce una ArithmeticException , que se puede evitar con una simple comprobación en el divisor. Del mismo modo, podemos evitar NullPointerException simplemente verificando las referencias: if (object != null) o incluso utilizando mejores técnicas .

Error:

  • Error refiere a una situación irrecuperable que no está siendo manejada por un try/catch .
  • Ejemplo: OutOfMemoryError , OutOfMemoryError , AssertionError , etc.

¿Por qué tantos tipos?

Además de la respuesta de Stephen C , quiero decir que el manejo de excepciones es una operación relativamente costosa en Java. No deberíamos poner todas las situaciones excepcionales en un bloque try/catch . El uso excesivo de try/catch s puede obstaculizar el rendimiento del progtwig.

En conclusión, Exception s debe manejarse mediante progtwigción siempre que sea posible. Por otro lado, no podemos manejar los Error , por lo que estas podrían ser algunas razones lógicas por las que hay muchos tipos de excepciones.

La respuesta de TofuBeer explica claramente lo que significan las clases de excepción.

¿Por qué estos muchos tipos? En cambio, Java simplemente puede seguir un diseño simple (simplemente intente / atrape todos los tipos) para manejar una condición anormal en un progtwig.

¿Por qué? Porque son necesarios! Sin esas 4 clases, manejar las excepciones por categoría amplia no sería práctico.

  • ¿Cómo detectaría “todos los errores fatales de JVM” sin la clase Error ?
  • ¿Cómo detectaría “todas las excepciones que no son errores fatales de JVM” sin la clase Exception ?
  • ¿Cómo captarías “todas las excepciones sin RuntimeException ” sin la clase RuntimeException ?

Las excepciones de tiempo de ejecución le brindan la flexibilidad de evitar la captura, declarando las excepciones.

  • Error (tira por VM, no debe ser capturado o manejado)
    1. Error de VM
    2. Error de asercion
    3. Error de vinculación … etc.
  • Runtime / Uncheck Exception (error de progtwigción, no debe ser capturado o manejado)
    1. Excepción de puntero nulo
    2. ArrayIndexOutOfBoundException
    3. IllegalArgumentException … etc.
  • Check Exception (Cualquier otra excepción), se espera que las aplicaciones sean capturadas o manejadas
    1. IOException
    2. FileNotFoundException
    3. SQLException … etc.

Diferencia entre excepciones controladas y no verificadas:

Tenemos muchas diferencias entre la excepción activada y la no comprobada, pero todas las diferencias se originan a partir de una consideración básica que es si la excepción se puede resolver por comstackdor o no.

Puntos para recordar son:

[1] Excepción marcada significa Comstackdor verificado Excepciones . Significa que el comstackdor exige que dicha excepción sea manejada por try-catch bloquee o arroje la palabra clave.

[2] Las excepciones no verificadas son aquellas para las que el comstackdor no proporciona ningún mandato, ya que el desarrollador puede resolverlas codificando / progtwigndo, ya que el flujo de control es controlable como en ArithmeticException, NullPointerException ArrayIndexOutOfBoundsException, IllegalArgumentException, etc.

Lo llamo “Exception-Identity-Test”, donde toma cualquier excepción aleatoria del documento de Java y solo le hace una pregunta. “¡Hola, excepción! ¿Se puede resolver programáticamente?

Si la excepción dice SÍ, entonces se trata de una excepción sin marcar, ya que puede resolverse con un cambio de código o resolviendo algún error de cálculo, etc.

Por otro lado, si la Excepción dice No , esto es Excepción comprobada como comprobada. El flujo de control de excepción sale de nuestro código como si alguien cambia las contraseñas de la Base de datos o alguien desconecta el cable de red, tiempo de espera de conexión (ConnectException), no se encuentra algún recurso ( FileNotFoundException, ClassNotFound), SQLException, InvocatonTargetException, etc. Estos no se pueden resolver mediante la progtwigción

    Intereting Posts