Comment gérer correctement les exceptions Java

IllegalArgumentException
Afin d'attraper cette exception, vous devez aller à l'endroit où
someMethod()
est appelé et utilisez le bloc try-catch :
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Tout dans le essayer block s'exécutera dans l'ordre jusqu'à ce qu'une exception soit levée. Dès qu'une exception est levée, toutes les instructions suivantes sont ignorées et la logique de l'application saute immédiatement au attraper bloquer.
 
Dans notre exemple, nous entrons dans le bloc try et appelons immédiatement
someMethod()
. Comme 200 n'est pas compris entre 0 et 100, un
IllegalArgumentException
Est lancé. Ceci met immédiatement fin à l'exécution de
someMethod()
, ignore le reste de la logique dans le bloc try (
someOtherMethod()
n'est jamais appelé) et reprend l'exécution dans le bloc catch.
 
Que se passerait-il si nous appelions
someMethod(50)
au lieu? Les
IllegalArgumentException
ne serait jamais jeté.
someMethod()
s'exécuterait normalement. Le bloc try s'exécuterait normalement, en appelant
someOtherMethod()
lorsque someMethod() se termine. Lorsque
someOtherMethod()
se termine, le bloc catch serait ignoré et
callingMethod()
continuerait.
 
Notez que vous pouvez avoir plusieurs blocs catch par bloc try :
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 } catch (NullPointerException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Notez également qu'une option finalement le bloc existe aussi :
public void method() {  
 try {  
 // ...  
 } catch (Exception e) {  
 // ...  
 } finally {  
 // ...  
 }  
}
Le code dans un bloc finally est toujours exécuté quoi qu'il arrive. Si vous avez une instruction return dans le bloc try, le bloc finally est exécuté avant de sortir de la méthode. Si vous lancez une autre exception dans le bloc catch, le bloc finally est exécuté avant que l'exception ne soit levée.
 
Vous devez utiliser le bloc finally lorsque vous avez des objets qui doivent être nettoyés avant la fin de la méthode. Par exemple, si vous avez ouvert un fichier dans le bloc try et levé plus tard une exception, le bloc finally vous permet de fermer le fichier avant de quitter la méthode.
 
Notez que vous pouvez avoir un bloc finally sans bloc catch :
public void method() {  
 try {  
 // ...  
 } finally {  
 // ...  
 }  
}
Cela vous permet d'effectuer tout nettoyage nécessaire tout en autorisant les exceptions levées à se propager dans la pile d'appel de méthode (c'est-à-dire que vous ne voulez pas gérer l'exception ici mais que vous devez toujours nettoyer en premier).
 
Exceptions cochées et non cochées en Java
Contrairement à la plupart des langages, Java fait la distinction entre exceptions vérifiées et exceptions non vérifiées (par exemple, C# n'a que des exceptions non vérifiées). Une exception vérifiée doit être pris dans la méthode où l'exception est levée, sinon le code ne sera pas compilé.
 
Pour créer une exception vérifiée, étendez de
Exception
. Pour créer une exception non cochée, étendez de
RuntimeException
.
 
Toute méthode qui lève une exception vérifiée doit l'indiquer dans la signature de la méthode en utilisant le jette mot-clé. Étant donné que Java est intégré
IOException
est une exception vérifiée, le code suivant ne sera pas compilé :
public void wontCompile() {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Vous devez d'abord déclarer qu'il lève une exception vérifiée :
public void willCompile() throws IOException {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Notez qu'une méthode peut être déclarée comme levant une exception mais ne le fait jamais réellement. Même ainsi, l'exception devra toujours être interceptée, sinon le code ne sera pas compilé.
 
Quand utiliser les exceptions cochées ou non cochées ?
 
La documentation officielle de Java a un page sur cette question . Il résume la différence avec une règle empirique succincte : « Si un client peut raisonnablement s'attendre à récupérer 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 une exception non contrôlée.'
 
Mais cette directive est peut-être dépassée. D'une part, les exceptions vérifiées donnent un code plus robuste . D'un autre côté, aucun autre langage n'a vérifié les exceptions de la même manière que Java, ce qui montre deux choses : premièrement, la fonctionnalité n'est pas assez utile pour que d'autres langages la volent, et deuxièmement, vous pouvez absolument vous en passer. De plus, les exceptions vérifiées ne fonctionnent pas bien avec les expressions lambda introduites dans Java 8.
 
Instructions pour l'utilisation des exceptions Java
 
Les exceptions sont utiles mais facilement mal utilisées et abusées. Voici quelques conseils et bonnes pratiques pour vous aider à éviter de les salir.
 
 
  Préférez les exceptions spécifiques aux exceptions générales. Utilisez |_+_| sur |_+_| lorsque cela est possible, sinon utilisez |_+_| sur |_+_| quand c'est possible.
 
  Ne jamais attraper |_+_| ! Le |_+_| la classe étend en fait |_+_| , et le bloc catch fonctionne en fait avec |_+_| ou toute classe qui étend Throwable. Cependant, le |_+_| la classe étend également |_+_| , et vous ne voulez jamais attraper un |_+_| parce que |_+_| s indiquent de graves problèmes irrécupérables.
 
  Ne jamais attraper |_+_| ! |_+_| étend |_+_| , donc tout bloc qui attrape |_+_| attrapera également |_+_| , et c'est une exception très importante avec laquelle vous ne voulez pas vous embrouiller (en particulier dans les applications multithreads) à moins que vous ne sachiez ce que vous faites. Si vous ne savez pas quelle exception intercepter à la place, envisagez de ne rien intercepter.
 
  Utilisez des messages descriptifs pour faciliter le débogage. Lorsque vous lancez une exception, vous pouvez fournir un |_+_| message comme argument. Ce message est accessible dans le bloc catch en utilisant le |_+_| méthode, mais si l'exception n'est jamais interceptée, le message apparaîtra également dans le cadre de la trace de la pile.
 
  Essayez de ne pas attraper et ignorer les exceptions. Pour contourner l'inconvénient des exceptions vérifiées, de nombreux programmeurs débutants et paresseux configureront un bloc catch mais le laisseront vide. Mauvais! Gérez-le toujours avec élégance, mais si vous ne pouvez pas, imprimez au moins une trace de pile afin que vous sachiez que l'exception a été levée. Vous pouvez le faire en utilisant le |_+_| méthode.
 
  Attention à ne pas abuser des exceptions. Quand vous avez un marteau, tout ressemble à un clou. Lorsque vous découvrez les exceptions pour la première fois, vous pouvez vous sentir obligé de tout transformer en exception... au point que la plupart du flux de contrôle de votre application se résume à la gestion des exceptions. N'oubliez pas que les exceptions sont destinées à des événements « exceptionnels » !
 
 
Maintenant, vous devriez être suffisamment à l'aise avec les exceptions pour comprendre ce qu'elles sont, pourquoi elles sont utilisées et comment les incorporer dans votre propre code. Si vous ne comprenez pas complètement le concept, ce n'est pas grave ! Il m'a fallu un certain temps pour que cela 'cliquent' dans ma tête, alors ne vous sentez pas obligé de vous précipiter. Prends ton temps.
 
  Vous avez des questions ? Connaissez-vous d'autres astuces liées aux exceptions que j'ai manquées ? Partagez-les dans les commentaires ci-dessous!  
  Partager    Partager      Tweeter      E-mail      Comment créer un diagramme de flux de données pour visualiser les données de n'importe quel projet  
Les diagrammes de flux de données (DFD) de tout processus vous aident à comprendre comment les données circulent de la source à la destination. Voici comment le créer !
Lire la suite   Rubriques connexes  
 
La programmation
 
Java
 
  A propos de l'auteur   Joël Lee(1524 articles publiés)            
Joel Lee est rédacteur en chef de MakeUseOf depuis 2018. Il est titulaire d'un B.S. en informatique et plus de neuf ans d'expérience professionnelle en rédaction et en édition.
votre pc/appareil doit être réparé 0xc0000225
Plus de Joel Lee
Abonnez-vous à notre newsletter
 
Rejoignez notre newsletter pour des conseils techniques, des critiques, des ebooks gratuits et des offres exclusives !
Cliquez ici pour vous abonner