Lancers ou try-catch
Quelle est la règle générale pour décider d'ajouter ou non une clause throws à une méthode ou d'utiliser un try-catch?
D'après ce que j'ai lu moi-même, la throws devrait être utilisée lorsque l'appelant a rompu le contrat (objet transmis) et le try-catch devrait être utilisé lorsqu'une exception se produit lors d'une opération effectuée dans la méthode. Est-ce correct? Si oui, que devrait-on faire du côté des appelants?
P.S: Recherche dans Google et SO mais souhaite une réponse claire à cette question.
- attraper une exception que si vous pouvez la gérer de manière significative
- déclarer en levant l'exception si elle doit être traitée par le consommateur de la méthode en cours
- lance des exceptions si elles sont causées par les paramètres d'entrée (mais celles-ci sont plus souvent décochées)
En général, une méthode doit émettre une exception à son appelant lorsqu'elle ne peut pas gérer le problème associé localement. Par exemple. Si la méthode est supposée lire dans un fichier avec le chemin donné, IOExceptions ne peut pas être manipulé localement de manière rationnelle. Il en va de même pour les entrées non valides, en ajoutant que mon choix personnel serait de lever une exception non contrôlée telle que IllegalArgumentException dans ce cas.
Et il devrait attraper une exception d'une méthode appelée it si:
- c'est quelque chose qui peut être manipulé localement (par exemple, essayer de convertir une chaîne d'entrée en un nombre, et si la conversion échoue, il est tout à fait valide de renvoyer une valeur par défaut à la place),
- ou ne devrait pas être jeté (par exemple, si l'exception provient d'une couche inférieure spécifique à l'implémentation, dont les détails d'implémentation ne devraient pas être visibles pour l'appelant - par exemple, je ne veux pas montrer que mon
DAOutiliseHibernatepour conserver mes entités , j'attrape donc tous lesHibernateExceptionslocalement et les convertis dans mes propres types d'exception).
Ma règle personnelle pour cela est simple:
- Puis-je le gérer de manière significative (ajouté à partir d'un commentaire)? Alors mettez le code dans
try/catch. Par manipuler, j'entends pouvoir informer l'utilisateur/récupérer d'une erreur ou, dans un sens plus large, comprendre comment cette exception affecte l'exécution de mon code. - Ailleurs, jetez-le
Remarque: cette réplique est désormais un wiki de communauté, n'hésitez pas à ajouter plus d'informations dans.
Voici comment je l'utilise:
Lance:
- Vous voulez juste que le code s'arrête quand une erreur se produit.
- Bon avec les méthodes sujettes à des erreurs Si certaines conditions préalables ne sont pas remplies
Try-Catch:
- Lorsque vous souhaitez que le programme Se comporte différemment avec des erreurs différentes
- Parfait si vous souhaitez fournir des erreurs meaning aux utilisateurs finaux.
Je connais beaucoup de gens qui utilisent toujours Throws parce que c'est plus propre, mais il y a simplement moins de contrôle.
La décision d'ajouter une clause try-catch ou throws à vos méthodes dépend de "comment vous souhaitez (ou devez gérer) votre exception".
Comment traiter une exception est une question large et loin d’être triviale. Cela implique notamment de décider où manipuler l'exception et quelles actions mettre en œuvre dans le bloc catch. En fait, la gestion d'une exception devrait être une décision de conception globale.
Pour répondre à vos questions, il n’ya pas de règle générale.
Vous devez décider où vous voulez gérer votre exception et cette décision est généralement très spécifique à votre domaine et aux exigences de votre application.
Si la méthode où l'exception a été levée dispose d'une quantité suffisante d'informations pour la traiter, alors elle devrait capturer, générer des informations utiles sur ce qui s'est passé et quelles données ont été traitées.
Quand utiliser quoi. J'ai beaucoup cherché à ce sujet. Il n'y a pas de règle absolue.
"Mais en tant que développeur, les exceptions Checked doivent être incluses dans une clause throws de la méthode. Cela est nécessaire pour que le compilateur sache les exceptions à vérifier . Par convention, les exceptions non vérifiées ne devraient pas être incluses dans une clause throws.
Leur inclusion est considérée comme une mauvaise pratique de programmation. Le compilateur les traite comme des commentaires et ne les vérifie pas. "
Source: livre SCJP 6 de Kathy Sierra
Une méthode ne devrait que throws une exception si elle peut apporter des garanties raisonnables concernant l'état de l'objet, les paramètres transmis à la méthode et tous les autres objets sur lesquels la méthode agit. Par exemple, une méthode qui est supposée extraire d'une collection un élément que l'appelant s'attend à y contenir peut peut-être throws une exception vérifiée si l'élément qui devait exister dans la collection ne le fait pas. Un appelant qui intercepte cette exception doit s'attendre à ce que la collection ne contienne pas l'élément en question.
Notez que bien que Java permette aux exceptions vérifiées de faire surface avec une méthode déclarée comme générant des exceptions des types appropriés, une telle utilisation devrait généralement être considérée comme un anti-modèle. Imaginons, par exemple, qu’une méthode LookAtSky() soit déclarée comme appelant FullMoonException et qu’elle soit supposée la lancer lorsque la Lune est pleine; imaginons en outre que LookAtSky() appelle ExamineJupiter(), qui est également déclaré en tant que throws FullMoonException. Si une FullMoonException est lancée par ExamineJupiter(), et si LookAtSky() ne l'attrape pas et ne la manipule pas ou ne l'enveloppe pas dans un autre type d'exception, le code appelé LookAtSky supposera que l'exception est le résultat de la lune pleine de la Terre; cela n'indiquerait pas qu'une des lunes de Jupiter pourrait en être le coupable.
Les exceptions qu'un appelant peut s'attendre à gérer (y compris essentiellement toutes les exceptions vérifiées) ne devraient être autorisées à traverser une méthode que si l'exception signifiait la même chose pour l'appelant de la méthode comme cela signifiait pour la méthode appelée. Si le code appelle une méthode déclarée comme générant une exception vérifiée, mais que l'appelant ne s'attend pas à ce qu'elle lève cette exception en pratique (par exemple, parce qu'il pense que les arguments de la méthode sont pré-validés), l'exception vérifiée doit être capturée et encapsulée. dans certains types d'exception non cochée. Si l'appelant ne s'attend pas à ce que l'exception soit levée, il ne peut pas s'attendre à ce qu'elle ait une signification particulière.
la paire try-catch est utilisée lorsque vous souhaitez fournir un comportement de personnalisation, au cas où une exception se produirait ..... autrement dit ... vous avez une solution à votre problème (occurrence d'exception) selon les exigences de votre programme .... .
Cependant, les jets sont utilisés lorsque vous n'avez pas de solution spécifique concernant le cas d'occurrence d'exception ... vous ne voulez tout simplement pas obtenir une terminaison anormale de votre programme ....
J'espère que c'est correct :-)
Si vous utilisez une tentative try, lorsque l'exception se produit, les codes restants seront toujours exécutés.
Si vous indiquez la méthode pour lever l'exception, le code cesse alors d'être exécuté immédiatement.