Diferencia entre java.lang.RuntimeException y java.lang.Salvedad

En Java, hay dos tipos de excepciones: excepciones verificadas y excepciones no verificadas. Una excepción comprobada debe ser manejada explícitamente por el código, mientras que una excepción no comprobada no necesita ser manejada explícitamente.

Para las excepciones marcadas, debe colocar un bloque try / catch alrededor del código que potencialmente podría lanzar la excepción, o agregar una cláusula "throws" al método, para indicar que el método podría lanzar este tipo de excepción (que debe manejarse en la clase que llama o superior).

Cualquier excepción que se derive de "Exception" es una excepción marcada, mientras que una clase que se derive de RuntimeException no está marcada. RuntimeExceptions no necesita ser manejado explícitamente por el código de llamada.

Antes de mirar la diferencia entre las clases java.lang.RuntimeException y java.lang.Exception, debe conocer la jerarquía Exception. Ambas clases Exception y Error se derivan de la clase Throwable (que se deriva de la clase Object). Y la clase RuntimeException se deriva de la clase Exception.

Todas las excepciones se derivan de Exception o RuntimeException.

Todas las excepciones que se derivan de RuntimeException se conoce como desactivada excepciones. Y todas las demás excepciones son comprobado excepciones. Una excepción marcada debe ser capturada en algún lugar de su código, de lo contrario, no se compilará. Es por eso que se llaman excepciones comprobadas. Por otro lado, con excepciones no marcadas, el método de llamada no tiene la obligación de manejarlo o declararlo.

Por lo tanto, todas las excepciones que el compilador te obliga a manejar se derivan directamente de java.lang.Exception y todas las demás que el compilador no te obliga a manejar se derivan de java.lang.RuntimeException.

Las siguientes son algunas de las subclases conocidas directas de RuntimeException.

AnnotationTypeMismatchException,
ArithmeticException,
ArrayStoreException,
BufferOverflowException,
BufferUnderflowException,
CannotRedoException,
CannotUndoException,
ClassCastException,
CMMException,
ConcurrentModificationException,
DataBindingException,
DOMException,
EmptyStackException,
EnumConstantNotPresentException,
EventException,
IllegalArgumentException,
IllegalMonitorStateException,
IllegalPathStateException,
IllegalStateException,
ImagingOpException,
IncompleteAnnotationException,
IndexOutOfBoundsException,
JMRuntimeException,
LSException,
MalformedParameterizedTypeException,
MirroredTypeException,
MirroredTypesException,
MissingResourceException,
NegativeArraySizeException,
NoSuchElementException,
NoSuchMechanismException,
NullPointerException,
ProfileDataException,
ProviderException,
RasterFormatException,
RejectedExecutionException,
SecurityException,
SystemException,
TypeConstraintException,
TypeNotPresentException,
UndeclaredThrowableException,
UnknownAnnotationValueException,
UnknownElementException,
UnknownTypeException,
UnmodifiableSetException,
UnsupportedOperationException,
WebServiceException 

Se marca una excepción y se desactiva una excepción de RuntimeException.

Marcado significa que el compilador requiere que manejes la excepción en un catch, o declare que tu método la lanza (o una de sus superclases).

Generalmente, lanza una excepción marcada si se espera que el llamante de la API maneje la excepción, y una excepción sin marcar si es algo que el llamante normalmente no podría manejar, como un error con uno de los parámetros, es decir, un error de programación.

Las clases de excepción en tiempo de ejecución (RuntimeException y sus subclases) están exentas de la comprobación en tiempo de compilación, ya que el compilador no puede establecer que las excepciones en tiempo de ejecución no puedan ocurrir. (de JLS).

En las clases que diseñe debe subclase Exception y lanzar instancias de para señalar cualquier escenario excepcional. Al hacerlo, estará señalando explícitamente la clientes de su clase que el uso de su clase podría lanzar excepción y tienen que tomar medidas para maneja esos escenarios excepcionales.

Los fragmentos de código siguientes explican este punto:

//Create your own exception class subclassing from Exception
class MyException extends Exception {
    public MyException(final String message) {
        super(message);
    }
}

public class Process {
    public void execute() {
        throw new RuntimeException("Runtime");
    }  
    public void process() throws MyException {
        throw new MyException("Checked");
    }
}

En la definición de clase anterior de class Process , el método execute puede throw a RuntimeException pero la declaración del método no necesita especificar que lanza RuntimeException.

El método process lanza una excepción marcada y debe declarar que lanzará una excepción de tipo marcada MyException y no hacerlo será una compilación error.

La definición de clase anterior también afectará al código que usa la clase Process.

La llamada new Process().execute() es una invocación válida donde como la llamada de forma new Process().process() da un error de compilación. Esto se debe a que el código del cliente debe tomar medidas para manejar MyException (digamos que la llamada a process () se puede incluir en un bloque try/catch).

Uso adecuado de RuntimeException?

De Excepciones no controladas The La Controversia :

Si se puede esperar razonablemente un cliente para recuperarse de una excepción, hacen una excepción marcada. Si un cliente no puede hacer nada para recuperarse de la exception, make it an unchecked salvedad.

Tenga en cuenta que una excepción no marcada es una derivada de RuntimeException y una excepción marcada es una derivada de Exception.

¿Por qué lanzar un RuntimeException si un cliente no puede hacer nada para recuperarse de la excepción? El artículo explica:

Las excepciones en tiempo de ejecución representan problemas que son el resultado de una programación problema, y como tal, el cliente API no se puede esperar razonablemente que el código recuperar de ellos o para manejarlos en de cualquier manera. Tales problemas incluyen excepciones aritméticas, tales como dividir por cero; excepciones de puntero, como intentar acceder a un objeto a través de una referencia nula; e indexación excepciones, como intentar acceder a un elemento array a través de un índice que es demasiado grande o demasiado pequeño.

De la documentación de oracle:

Aquí está la guía de la línea de fondo: Si un cliente puede razonablemente ser espera recuperarse de una excepción, hacen una excepción comprobada. Si un cliente no puede hacer nada para recuperarse de la excepción, que sea un excepción sin marcar.

Las excepciones en tiempo de ejecución representan problemas que son el resultado de un problema de programación y, como tal, no se puede esperar razonablemente que el código del cliente API se recupere de ellos o los maneje de cualquier manera.

RuntimeExceptions son como "excepciones por uso no válido de una api" ejemplos de runtimeexceptions: IllegalStateException, NegativeArraySizeException, NullPointerException

Con las excepciones, debe capturarlo explícitamente porque aún puede hacer algo para recuperarse. Ejemplos de excepciones son: IOException, TimeoutException, PrintException...

En palabras simples, si su cliente/usuario puede recuperarse de la Excepción, entonces hágalo un Marcado Exception , si su cliente no puede hacer nada para recuperarse de la Excepción, hágalo sin marcar RuntimeException . Por ejemplo, una RuntimeException sería un error programático, como la división por cero, ningún usuario puede hacer nada al respecto sino el propio programador, entonces es una RuntimeException.

RuntimeException es una clase secundaria de Exception class

Esta es una de las muchas clases secundarias de la clase Exception. RuntimeException es la superclase de aquellas excepciones que se pueden lanzar durante el funcionamiento normal de la Máquina Virtual Java. Un método no está obligado a declarar en su cláusula throws ninguna subclase de RuntimeException que pueda ser lanzada durante la ejecución del método pero no capturada.

El hierchy is

Java.lang.Objeto

---java.lang.Arrojar

-------java.lang.Excepción

-------------java.lang.RuntimeException

Las excepciones son una buena manera de manejar eventos inesperados en el flujo de su aplicación. RuntimeException no está marcada por el Compilador, pero es posible que prefiera usar Excepciones que amplíen la clase Exception para controlar el comportamiento de sus clientes api, ya que son necesarios para detectar errores para que compilen. También forma buena documentación.

Si desea lograr una interfaz limpia, use herencia para subclase los diferentes tipos de excepción que tiene su aplicación y luego exponga el padre salvedad.

Hay dos tipos de excepción, puede recuperarse de la excepción marcada si obtiene ese tipo de excepción. Las excepciones de tiempo de ejecución son irrecuperables, las excepciones de tiempo de ejecución son errores de programación, y el programador debe encargarse de ello mientras escribe el código, y continuar la ejecución de esto podría darle un resultado incorrecto. Las excepciones en tiempo de ejecución se refieren a la violación de la precondición ex. tiene una matriz de tamaño 10, y está tratando de acceder al elemento 11, lanzará ArrayIndexOutOfBoundException

1. La excepción definida por el usuario se puede marcar Excepción o Excepción no marcada, depende de la clase a la que se extiende.

2. La excepción definida por el usuario se puede marcar como Excepción Personalizada, si se extiende a la clase de excepción

3. La excepción definida por el usuario puede ser una Excepción personalizada sin marcar , si se extiende a la clase de excepción en tiempo de ejecución.

4. Definir una clase y convertirla en un hijo de Exception o Run time Exception