Jette ou essaie + attraper

Quelle est la règle générale pour décider d’append une clause throws à une méthode ou d’utiliser un try-catch?

D’après ce que j’ai lu moi-même, les lancers doivent être utilisés lorsque l’appelant a rompu la fin du contrat (object passé) et que le try-catch doit être utilisé lorsqu’une exception a lieu pendant une opération effectuée à l’intérieur du contrat. méthode. Est-ce correct? Si oui, que devrait-on faire du côté des appelants?

PS: Recherche dans Google et SO mais souhaite une réponse claire sur celui-ci.

  • attraper une exception seulement si vous pouvez la gérer de manière significative
  • déclarer lancer l’exception si elle doit être traitée par le consommateur de la méthode en cours
  • Jeter des exceptions si elles sont causées par les parameters d’entrée (mais celles-ci sont plus souvent décochées)

En général, une méthode doit lancer une exception à son appelant lorsqu’il ne peut pas gérer le problème associé localement. Par exemple, si la méthode est supposée lire un fichier avec le chemin donné, les exceptions IOExceptions ne peuvent pas être gérées localement de manière sensée. La même chose s’applique pour les entrées non valides, ajoutant que mon choix personnel serait de lancer une exception non contrôlée comme IllegalArgumentException dans ce cas.

Et il devrait attraper une exception d’une méthode appelée si

  • c’est quelque chose qui peut être manipulé localement (par exemple, essayer de convertir une chaîne d’entrée en nombre, et si la conversion échoue, il est tout à fait correct de retourner une valeur par défaut),
  • ou elle ne doit pas être lancée (par exemple si l’exception provient d’une couche inférieure spécifique à l’implémentation, dont les détails d’implémentation ne doivent pas être visibles pour l’appelant – par exemple, je ne veux pas montrer que mon DAO utilise Hibernate pour persister mes entités , donc j’attrape toutes les HibernateExceptions localement et les convertis en mes propres types d’exception).

Ma règle de base personnelle pour cela est simple:

  • Puis-je le gérer de manière significative (ajouté à partir d’un commentaire)? Donc, mettez le code dans try/catch . En le manipulant, je veux dire pouvoir informer l’utilisateur / récupérer de l’erreur ou, dans un sens plus large, être capable de comprendre comment cette exception affecte l’exécution de mon code.
  • Ailleurs, jetez-le

Note: ce replys est maintenant un wiki de communauté, n’hésitez pas à append plus d’informations dans.

Voici comment je l’utilise:

Jette:

  • Vous voulez juste que le code s’arrête quand une erreur survient.
  • Bon avec des méthodes sujettes aux erreurs si certaines conditions préalables ne sont pas remplies.

Try-Catch:

  • Lorsque vous voulez que le programme se comporte différemment avec des erreurs différentes.
  • Parfait si vous voulez fournir des erreurs significatives aux utilisateurs finaux.

Je connais beaucoup de gens qui utilisent toujours les lancers parce que c’est plus propre, mais il n’y a tout simplement pas autant de contrôle.

La décision d’append une clause try-catch ou throws à vos méthodes dépend de “comment vous voulez (ou avez besoin) de gérer votre exception”.

Comment gérer une exception est une question large et loin d’être sortingviale à laquelle répondre. Cela implique en particulier de décider où gérer l’exception et quelles actions implémenter dans le bloc catch. En fait, comment gérer une exception devrait être une décision de conception globale.

Donc, répondant à vos questions, il n’y a 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 dans laquelle l’exception a été générée contient une quantité suffisante d’informations pour y faire face, elle doit générer des informations utiles sur ce qui s’est passé et sur les données en cours de traitement.

Une méthode ne doit throws une exception que si elle peut apporter des garanties raisonnables concernant l’état de l’object, tous les parameters transmis à la méthode et tout autre object sur lequel la méthode agit. Par exemple, une méthode qui est supposée récupérer à partir d’une collection un élément que l’appelant s’attend à contenir peut 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 même si Java autorisera les exceptions vérifiées à travers une méthode déclarée comme générant des exceptions pour les types appropriés, cet usage devrait généralement être considéré comme un anti-modèle. Imaginons, par exemple, que certaines méthodes LookAtSky() soient déclarées comme appelant FullMoonException , et FullMoonException devraient le lancer lorsque la Lune est pleine; Imaginez plus loin que LookAtSky() appelle ExamineJupiter() , qui est également déclaré en tant que throws FullMoonException . Si ExamineJupiter() FullMoonException une FullMoonException et si LookAtSky() ne le LookAtSky() pas et le manipulait ou l’enveloppait dans un autre type d’exception, le code appelé LookAtSky supposerait que l’exception était due au fait que la Lune était pleine. ; cela n’aurait aucune idée que l’une des lunes de Jupiter pourrait ê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 signifie la même chose pour l’appelant de la méthode que pour la méthode appelée. Si le code appelle une méthode qui est déclarée en tant que jetant une exception vérifiée, mais que l’appelant ne s’attend pas à ce qu’il jette cette exception dans la pratique (par exemple parce qu’il pense qu’il s’agit d’arguments de méthode pré-validés) dans un type d’exception non contrôlé. Si l’appelant ne s’attend pas à ce que l’exception soit lancée, l’appelant ne peut pas s’attendre à ce qu’il ait une signification particulière.

Si vous utilisez un try try, lorsque l’exception se produit, les codes restants seront toujours exécutés.

Si vous indiquez la méthode pour lancer l’exception, alors, lorsque l’exception se produit, le code cessera d’être exécuté immédiatement.

La paire try-catch est utilisée lorsque vous souhaitez fournir un comportement de personnalisation, au cas où une exception se produirait ….. en d’autres termes … vous avez une solution à votre problème (occurrence d’exception) conformément aux exigences de votre programme …. .

Mais les lancers sont utilisés lorsque vous ne disposez d’aucune solution spécifique concernant le cas d’occurrence d’exception … vous ne voulez tout simplement pas avoir une fin anormale de votre programme ….

J’espère que c’est correct 🙂