Différence entre Java.lang.RuntimeException et Java.lang.Exception
Quelqu'un s'il vous plaît expliquer la différence entre Java.lang.RuntimeException et Java.lang.Exception? Comment décider lequel prolonger si je crée ma propre exception?
Généralement RuntimeExceptions sont des exceptions qui peuvent être évités par programme. E.g NullPointerException, ArrayIndexOutOfBoundException. Si vous recherchez null avant d'appeler une méthode, NullPointerException ne se produira jamais. De même, ArrayIndexOutOfBoundException ne se produira jamais si vous vérifiez d'abord l'index. RuntimeException ne sont pas vérifiés par le compilateur, il s'agit donc d'un code vierge.
EDIT: Ces jours-ci, les gens préfèrent RuntimeException parce que le code propre qu'il produit. C'est totalement un choix personnel.
En Java, il existe deux types d'exceptions: les exceptions vérifiées et les exceptions non vérifiées. Une exception vérifiée doit être gérée explicitement par le code, tandis qu'une exception non vérifiée n'a pas besoin d'être explicitement gérée.
Pour les exceptions vérifiées, vous devez placer un bloc try/catch autour du code susceptible de générer l’exception, ou ajouter une clause "throws" à la méthode, pour indiquer que la méthode peut générer ce type traité dans la classe d'appel ou au-dessus).
Toute exception dérivée de "Exception" est une exception contrôlée, alors qu'une classe dérivée de RuntimeException est désélectionnée. Les exceptions RuntimeExceptions n'ont pas besoin d'être explicitement gérées par le code appelant.
Avant d'examiner la différence entre les classes Java.lang.RuntimeException et Java.lang.Exception, vous devez connaître la hiérarchie Exception. Les classes Exception et Error sont dérivées de la classe Throwable (qui provient de la classe Object). Et la classe RuntimeException est dérivée de la classe Exception.
Toutes les exceptions sont dérivées de Exception ou RuntimeException.
Toutes les exceptions issues de RuntimeException sont appelées exceptions non cochées. Et toutes les autres exceptions sont des exceptions vérifiées. Une exception vérifiée doit être interceptée quelque part dans votre code, sinon elle ne sera pas compilée. C'est pourquoi elles sont appelées exceptions vérifiées. D'autre part, avec des exceptions non vérifiées, la méthode d'appel n'est pas obligée de la gérer ou de la déclarer.
Par conséquent, toutes les exceptions que le compilateur vous oblige à gérer sont directement dérivées de Java.lang.Exception et toutes les autres que le compilateur ne vous oblige pas à manipuler sont dérivées de Java.lang.RuntimeException.
Voici quelques-unes des sous-classes directes connues 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
Une exception est vérifiée et une exception RuntimeException est décochée.
Coché signifie que le compilateur nécessite que vous gériez l'exception dans un catch ou que vous déclariez votre méthode comme la projetant (ou l'une de ses superclasses).
Généralement, lève une exception cochée si l’appelant de l’API est censée gérer l’exception, et une exception non vérifiée s’il s’agit d’un problème qu’il ne serait normalement pas en mesure de gérer, tel qu’une erreur avec un des paramètres, c erreur.
Les classes d'exceptions d'exécution (RuntimeException et ses sous-classes) sont exemptées de la vérification à la compilation, car le compilateur ne peut pas établir que des exceptions d'exécution ne peuvent pas se produire. (de JLS).
Dans les classes que vous concevez, vous devez sous-classer Exception et renvoyer des instances deit pour signaler tout scénario exceptionnel. Ce faisant, vous signalerez explicitement aux clients De votre classe que leur utilisation peut générer une exception et qu'ils doivent prendre des mesures pour gérer ces scénarios exceptionnels.
Les extraits de code ci-dessous expliquent ce point:
//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");
}
}
Dans la définition de classe ci-dessus Processus, la méthode execute peut jeter un RuntimeException mais la déclaration de méthode n'a pas besoin de spécifier que elle jette RuntimeException.
La méthode process lève une exception vérifiée et elle devrait déclarer que Lève une exception vérifiée de type MyException et ne pas le faire sera une erreur de compilation.
La définition de classe ci-dessus affectera le code qui utilise Processus classe aussi bien.
L'appel new Process().execute() est une invocation valide où en tant qu'appel de forme new Process().process() donne une erreur de compilation. En effet, le code client doit Prendre des mesures pour gérer MyException (par exemple, l'appel à process () peut être enfermé dans Un bloc try/catch).
Utilisation correcte de RuntimeException?
De Exceptions non contrôlées - La controverse :
Si un client peut raisonnablement être attendu pour récupérer d'une exception, faites-le une exception vérifiée. Si un client ne peut rien faire pour récupérer de la exception, faites-en une case décochée exception.
Notez qu'une exception non contrôlée est une exception dérivée de RuntimeException et une exception contrôlée en est une dérivée de Exception .
Pourquoi lancer une RuntimeException si un client ne peut rien faire pour récupérer de l'exception? L'article explique:
Les exceptions d'exécution représentent des problèmes qui sont le résultat d'une programmation problème, et en tant que tel, le client API le code ne peut raisonnablement être attendu à récupérer d'eux ou les manipuler en tous cas. Ces problèmes incluent exceptions arithmétiques, telles que divisant par zéro; exceptions de pointeur, comme essayer d'accéder à un objet via une référence nulle; et indexation des exceptions, telles que la tentative de accéder à un élément de tableau via un fichier indice trop grand ou trop petit.
De la documentation Oracle:
Voici la ligne directrice: Si un client peut raisonnablement être devrait récupérer à partir d’une exception, faites-en une exception vérifiée. Si un client ne peut rien faire pour récupérer de l'exception, faites-en un exception non contrôlée.
Les exceptions d'exécution représentent des problèmes résultant d'un problème de programmation et, en tant que tel, le code client de l'API ne peut raisonnablement pas être récupéré, ni traité de quelque manière que ce soit.
Les exceptions RuntimeExceptions ressemblent à des "exceptions dues à l'utilisation non valide d'une API" exemples d'exceptions d'exécution: IllegalStateException, NegativeArraySizeException, NullpointerException
Avec les exceptions, vous devez le comprendre explicitement car vous pouvez toujours faire quelque chose pour récupérer. Des exemples d'exceptions sont: IOException, TimeoutException, PrintException ...
En termes simples, si votre client/utilisateur peut récupérer de l’exception, faites-en un vérifiéException, si votre client ne peut rien faire pour récupérer de l’exception, attribuez-lui DécochéeRuntimeException. Par exemple, une exception RuntimeException serait une erreur de programmation, comme une division par zéro, aucun utilisateur ne peut rien y faire à part le programmeur lui-même. Il s’agit alors d’une exception RuntimeException.
RuntimeException est une classe enfant de la classe Exception
C'est l'une des nombreuses classes enfants de la classe Exception. RuntimeException est la super-classe des exceptions pouvant être levées lors du fonctionnement normal de la machine virtuelle Java. Une méthode n'est pas obligée de déclarer dans sa clause throws les sous-classes de RuntimeException qui pourraient être levées pendant l'exécution de la méthode mais non interceptées.
Le hierchy est
Java.lang.Object
--- Java.lang.Throwable
------- Java.lang.Exception
------------- Java.lang.RuntimeException
Les exceptions constituent un bon moyen de gérer les événements inattendus dans votre flux d'applications. Les exceptions RuntimeException ne sont pas cochées par le compilateur, mais vous préférerez peut-être utiliser des exceptions qui étendent Exception Class pour contrôler le comportement de vos clients api, car ils doivent capturer les erreurs à compiler. Forme également une bonne documentation.
Si vous souhaitez obtenir une interface propre, utilisez l'héritage pour sous-classer les différents types d'exceptions de votre application, puis exposer l'exception parent.
Il existe deux types d'exception. Vous pouvez récupérer une exception cochée si vous obtenez un tel type d'exception. Les exceptions d'exécution sont irrécupérables, les exceptions d'exécution sont des erreurs de programmation et le programmeur doit s'en occuper lors de l'écriture du code, et l'exécution de cette opération pourrait vous donner un résultat incorrect. Les exceptions d'exécution concernent la violation de la condition préalable ex. vous avez un tableau de taille 10, et vous essayez d'accéder au 11 ème élément, il lancera ArrayIndexOutOfBoundException
L'exception définie par l'utilisateur peut être une exception cochée ou une exception non cochée, elle dépend de la classe à laquelle elle s'étend.
L'exception définie par l'utilisateur peut être une exception vérifiée personnalisée, si elle s'étend à la classe d'exception
L'exception définie par l'utilisateur peut être une exception personnalisée non contrôlée, si elle s'étend à la classe d'exception d'exécution.
Définir une classe et en faire un enfant d'exception ou d'exception d'exécution