Quand Throwable doit-il être utilisé à la place de la nouvelle exception?
https://stackoverflow.com/questions/498217
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Donné: Throwable est la superclasse de Exception.
Lorsque je lis des textes en écrivant vos propres "exceptions", je vois des exemples d'utilisation de catch dans le bloc new Exception() et d'autres textes indiquant else en cours d'utilisation dans le bloc <=>. Je n’ai pas encore vu d’explication sur le moment de l’utilisation de chacun.
Ma question est la suivante: quand <=> doit-il être utilisé et quand <=> doit-il être utilisé?
À l'intérieur du bloc <=> ou <=> en utilisant:
throw throwable;
ou
throw new Exception();
La solution
(à partir de commentaires) La question qui a soulevé cette question est que Je dois passer une "exception" à un morceau de code qu'un collègue est en train de construire si une collection ne se construit pas.
Dans ce cas, vous pouvez générer une exception vérifiée . Vous pouvez lancer un Exception , un sous-classe existante appropriée de celle-ci (sauf RuntimeException et ses sous-classes décochées ), ou une sous-classe personnalisée de CollectionBuildException (par exemple, & "; <=> &";). Consultez le didacticiel Java sur les exceptions pour vous mettre à niveau. avec des exceptions Java.
Autres conseils
Jetez toujours un Exception (jamais un Throwable). En général, vous n’avez pas compris Error mais vous le pouvez. Throwable est la super-classe de <=> et de <=>. Ainsi, si vous vouliez capturer non seulement <=> s mais <=> s, vous attraperiez , le but est de l’avoir. En fait, <=> sont généralement des choses qu’une application normale n’aurait pas et ne devrait pas saisir, aussi utilisez-vous <=> sauf si vous avez une raison particulière d’utiliser <=>.
Vous ne devriez pas vraiment attraper une exception et en lancer une nouvelle aussi générale que & "nouvelle exception &";.
Au lieu de cela, si vous souhaitez masquer l'exception, procédez comme suit:
try {
// Do some stuff here
}
catch (DivideByZeroException e) {
System.out.println("Can't divide by Zero!");
}
catch (IndexOutOfRangeException e) {
// catch the exception
System.out.println("No matching element found.");
}
catch (Throwable e) {
throw e; // rethrow the exception/error that occurred
}
Ce n’est pas une bonne pratique, je crois, d’attraper une exception et de lancer une nouvelle exception à la place de celle qui a été levée dans votre bloc de code, à moins que vous ne leviez une exception personnalisée utile fournissant un contexte suffisant pour éluder la cause de l'exception originale.
Seulement deux endroits où vous devriez voir le mot Throwable dans le code:
public static void main(String args[])
{
try
{
// Do some stuff
}
catch(Throwable t)
{
}
}
ET
public class SomeServlet extends HttpServlet
{
public void doPost(HttpRequest request, HttpResponse response)
{
try
{
// Do some stuff
}
catch (Throwable t)
{
// Log
}
}
}
Throwable est une interface, pas une classe. Deux classes étendent Throwable, Exception et Error.
La règle est la suivante: soyez aussi précis que possible lorsque vous capturez des exceptions. Cela signifie, par exemple, capturer Exception au lieu de Throwable et IOException au lieu de Exception.
Ne pas attraper les erreurs - les erreurs sont des bugs. Fixez le code à la place.
Si vous devez absolument tout attraper, utilisez & "; attrapez Throwable &"; mais c'est une mauvaise forme.
throw new Exception(); est quelque chose que vous devriez ne jamais faire dans un bloc catch, mais vous devrez peut-être ou vouloir jeter new SomeException(throwable); (en conservant la trace de pile complète) au lieu de throw throwable; dans afin de se conformer à l'API de votre méthode, par exemple quand il déclare lancer SomeException mais que vous appelez du code susceptible de générer une IOException que vous ne souhaitez pas ajouter à la clause throws de votre méthode.
Le cas le plus courant est probablement new RuntimeException(throwable); pour éviter d'avoir une clause <=>. Beaucoup de gens vont vous dire que c'est un abus horrible parce que vous devriez utiliser des exceptions vérifiées. Selon l’OMI, elles sont fausses et les exceptions vérifiées sont une erreur dans la conception du langage Java qui aboutit simplement à un code laid et non maintenable.
Comme je l'ai entendu lorsque java est apparu pour la première fois, la théorie était que Throwable pourrait être utilisé pour le transfert de contrôle dans d'autres cas que des exceptions. Je ne l’ai jamais vu utilisé de cette façon (et c’est probablement une très bonne chose).
Alors attrapez simplement Exception (ou mieux encore, une exception plus fine).
Throwable est uniquement destiné à être capturé par le conteneur ou la boucle principale de votre programme. La plupart du temps, les erreurs capturées en dessous d’Exception, par exemple Error, n’ajoutent pas beaucoup de possibilités à un programme, après tout ce que vous pouvez faire si une autre erreur VirtualError est renvoyée. Pas grand chose à part vous connecter et continuer.
Toutes les exceptions posent problème à la fin ... aussi dire que les erreurs sont des bogues ne veut rien dire.
Les erreurs ne sont pas des bogues, mais des problèmes rencontrés par la machine virtuelle hôte, par exemple OutOfMemoryError. Les exceptions sont un moyen que l’opération en cours peut utiliser pour notifier l’échec et peut-être fournir un diagnostic.
En règle générale, vous ne voudriez pas lancer ou attraper Throwable. En particulier, les erreurs JVM (qui étendent Error ()) ne ne veulent pas être capturées par le code utilisateur, sauf si vous effectuez un travail étrange au niveau du système.
Traiter & "Jetable &"; comme artefact de langage. L'exception & Quot; & Quot; class est nommé ainsi car c'est celui que les programmeurs sont censés utiliser lorsqu'ils veulent qu'un bloc de code quitte & "exceptionnellement &"; - en ne quittant pas normalement ou en renvoyant une valeur.
Cela inclut à la fois les situations d'erreur habituelles (par & "normal"! je veux dire par opposition aux erreurs JVM) et les endroits où vous utilisez des exceptions comme mécanisme de contrôle.
Vous ne devez pas utiliser Exceptions en tant que & "type de retour &"; soit ...
Si la condition que vous lancez est courante, vous dépensez une quantité énorme de ressources pour la renvoyer à la routine d'appel. Les exceptions coûtent cher à construire.
J'ai vu des cas dans lesquels des boucles serrées jetaient des exceptions sous forme de " négatif " par exemple Attribution d’ID, cette routine a occupé environ 99% du temps CPU. Lorsqu’elle est passée à une constante de retour documentée, elle est tombée à 25%.
