try catch finally
Dans ce didacticiel, nous discuterons de divers mots-clés utilisés en Java pour la gestion des exceptions tels que Try, Catch, Enfin, Throw et Throws avec des exemples:
Dans nos tutoriels précédents, nous avons vu les bases de la gestion des exceptions en Java ainsi que les différentes exceptions prises en charge par la classe Java Exception. Nous avons également discuté de l'exception NullPointerException en détail.
Nous pouvons inclure des exceptions dans notre programme en utilisant certains mots clés fournis en Java. Ces mots-clés définissent divers blocs de code qui facilitent la définition et la gestion des exceptions.
=> Visitez ici pour la série exclusive de didacticiels de formation Java.
Ce que vous apprendrez:
Essayez, attrapez, enfin en Java
Les mots-clés ci-dessous sont utilisés en Java pour la gestion des exceptions.
- Essayer
- Capture
- finalement
- Lancer
- Jette
Le tableau suivant décrit brièvement ces mots-clés.
| Mot-clé | Description |
|---|---|
| Essayer | Nous spécifions le bloc de code qui pourrait donner lieu à l'exception dans un bloc spécial avec un mot-clé «Try». |
| Capture | Lorsque l'exception est déclenchée, elle doit être interceptée par le programme. Ceci est fait en utilisant un mot-clé «catch». Ainsi, un bloc catch suit le bloc try qui déclenche une exception. Le mot clé catch doit toujours être utilisé avec un essai. |
| finalement | Parfois, nous avons un code important dans notre programme qui doit être exécuté indépendamment du fait que l'exception soit lancée ou non. Ce code est placé dans un bloc spécial commençant par le mot-clé «Enfin». Le bloc Enfin suit le bloc Try-catch. |
| Lancer | Le mot-clé «throw» est utilisé pour lancer l'exception explicitement. |
| Jette | Le mot clé «Throws» ne lève pas d'exception mais est utilisé pour déclarer des exceptions. Ce mot clé est utilisé pour indiquer qu'une exception peut se produire dans le programme ou la méthode. |
Dans ce didacticiel, nous discuterons de tous les mots-clés ci-dessus en détail avec les exemples de programmation.
Essayez Block en Java
Chaque fois que nous écrivons un programme, il peut y avoir un code que nous soupçonnons de lever une exception. Par exemple, nous pourrions soupçonner qu'il pourrait y avoir une opération de «division par zéro» dans le code qui lèvera une exception.
Ce code susceptible de déclencher une exception est inclus dans un bloc avec le mot-clé «try». Ainsi, le bloc try contient le code ou l'ensemble d'instructions pouvant déclencher une exception.
La syntaxe générale du bloc try est la suivante:
try{ //set of statements that can raise exception } Par conséquent, si un programmeur pense que certaines instructions déclencheront des exceptions, placez ces instructions dans un bloc try. Notez que lorsqu'une exception se produit au niveau d'une instruction spécifique dans un bloc try, le reste du code n'est pas exécuté.
Lorsqu'une exception se produit dans un bloc try à une instruction particulière, le contrôle sort et le programme se termine brusquement. Pour éviter cette interruption brutale du programme, nous devons «gérer» cette exception. Cette manipulation se fait à l'aide du mot-clé «catch». Ainsi, un bloc try a toujours un bloc catch qui le suit.
Catch Block en Java
Nous utilisons un bloc catch pour gérer les exceptions. C'est le bloc avec le mot-clé «catch». Le bloc catch suit le bloc try.
Chaque fois qu'une exception se produit dans le bloc try, le code du bloc catch qui correspond à l'exception est exécuté.
La syntaxe générale du bloc catch est:
catch (Exception e){ //code to handle exception e }En général, l'exception déclarée doit être la classe parente de toutes les exceptions, c'est-à-dire Exception. Mais s'il y a plus d'une exception, nous pouvons également écrire des types d'exceptions spécifiques ou des exceptions générées.
Ensuite, nous discuterons du bloc try-catch. Notez que pour chaque bloc try, nous pouvons avoir plusieurs blocs catch.
Try-Catch Java
La syntaxe générale du bloc try-catch est indiquée ci-dessous:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Le bloc try peut avoir plusieurs lignes de code pouvant déclencher plusieurs exceptions. Chacune de ces exceptions est gérée par un bloc catch indépendant.
Le gestionnaire d'exceptions générique, objet e de la classe Exception, peut gérer toutes les exceptions, mais si nous voulons gérer des exceptions spécifiques, il est conseillé de spécifier le gestionnaire d'exceptions générique comme dernier bloc catch.
Exemple Java Try Catch
Voyons maintenant un bloc try-catch en Java. Ici, dans le bloc try, nous définissons une opération de division. Le diviseur est zéro. Ainsi, l'instruction qui divise les deux nombres lève une exception arithmétique. Nous avons un bloc catch qui définit un gestionnaire pour l'exception arithmétique.
Ci-dessous un exemple de programme Java.
class Main { public static void main(String args()) { int val1, val2; try { //this block will contain statements that may raise exceptions System.out.println('Try Block:: Start'); val1 = 0; val2 = 25 / val1; System.out.println(val2); System.out.println('Try Block:: End'); } catch (ArithmeticException e) { //handler for ArithmeticException System.out.println('ArithmeticException :: Divide by Zero!!'); } System.out.println('Outside try-catch:: Rest of the code.'); } } Production
à quoi ressemble un modem
Attraper plusieurs exceptions
Comme déjà mentionné, un bloc try peut contenir un code qui déclenche plus d'une exception. Dans ce cas, nous aurons besoin de plus d'un bloc catch pour gérer chaque exception. Un seul bloc try peut être suivi de plusieurs blocs catch. Chaque bloc catch gérera les exceptions indépendantes.
Dans le cas de plusieurs blocs catch, nous devons nous rappeler les points ci-dessous:
- Dans un programme Java, à tout moment, une seule exception peut se produire. De plus, à tout moment, un seul bloc catch est exécuté.
- Les blocs catch multiples doivent être ordonnés de telle manière que le bloc catch pour l'exception la plus spécifique doit venir en premier, puis le bloc général.
Par exemple, si nous avons ArithmeticException et General Exception, alors l'arithmeticException de gestion de bloc catch viendra en premier, suivi de l'exception de gestion de bloc catch.
L'exemple ci-dessous illustre plusieurs blocs catch.
public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); myArray (5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } } Production
Dans le programme ci-dessus, une ArithmeticException qui est interceptée dans le premier bloc catch est déclenchée. Si ce bloc catch n'était pas spécifié, alors l'exception se serait propagée au bloc catch généralisé.
Modifions légèrement le programme ci-dessus afin que le bloc try lève deux exceptions. Voyons maintenant la sortie.
public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); System.out.println('Array element 10 : ' + myArray(10)); myArray(5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } } Production
Si nous voyons cette sortie, cela montre que ArrayIndexOutOfBoundsException est levée. Ceci est dû au fait que l'instruction qui déclenche ArrayIndexOutOfBoundsException est exécutée en premier. L'exception est levée et le contrôle va au bloc catch correspondant.
Try-Catch imbriqué
Un bloc try à l'intérieur d'un autre bloc try est appelé un bloc try imbriqué. Nous avons besoin de telles structures dans certaines situations où un morceau de code contenu dans un code d'essai peut être tel que certaines lignes lèvent certaines exceptions et un autre morceau de code lève une exception complètement différente.
Dans le cas de blocs try imbriqués, d'abord, le bloc try le plus interne est exécuté et l'exception est gérée. Si le bloc try le plus interne n'a pas de bloc catch correspondant, il est alors propagé d'un niveau jusqu'à son bloc try parent. De cette façon, l'exception est propagée vers le haut jusqu'à ce que le gestionnaire d'exceptions correspondant soit trouvé.
S'il n'y a pas de gestionnaire d'exceptions correspondant à l'exception, alors le programme se termine brusquement avec un message généré par le système.
La syntaxe générale d'un bloc try imbriqué est donnée ci-dessous:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Implémentons un programme pour illustrer le bloc try-catch imbriqué.
class Main{ public static void main(String args()){ //Main try block try{ //try block1 try{ System.out.println('Try Block1'); int num =15/0; System.out.println(num); } catch(ArithmeticException e1){ System.out.println('Block1 Exception: e1'); } //try block2 try{ System.out.println('Try Block2'); int num =100/0; System.out.println(num); } catch(ArrayIndexOutOfBoundsException e2){ System.out.println('Block2 Exception: e2'); } System.out.println('General statement after Block1 and Block2'); } catch(ArithmeticException e3){ System.out.println('Main Block Arithmetic Exception'); } catch(ArrayIndexOutOfBoundsException e4){ System.out.println('Main Block ArrayIndexOutOfBoundsException'); } catch(Exception e5){ System.out.println('Main Block General Exception'); } System.out.println('Code after Nested Try Block'); } } Production
Dans le programme ci-dessus, nous avons deux blocs try inclus dans le bloc try principal. Les deux blocs try internes ont un code qui déclenche ArithmeticException. Mais nous avons fourni un bloc catch correspondant uniquement pour le premier bloc et non pour le deuxième bloc try.
Par conséquent, le deuxième bloc propage son exception vers le bloc try principal, puis le gère. Cela ressort clairement de la sortie.
Enfin bloquer en Java
Jusqu'à présent, nous avons vu le bloc try-catch et try imbriqué. Nous savons que le code censé déclencher l'exception est placé dans un bloc try. Lorsqu'une exception se produit, le reste du code dans le bloc try n'est pas exécuté.
Soit le programme se termine brusquement si une exception n'est pas gérée, soit le contrôle est passé au gestionnaire d'exceptions.
Dans une telle situation, il est nécessaire d'inclure un code qui doit être exécuté indépendamment du fait qu'une exception se produise ou non. Cela signifie que nous exécuterons un morceau de code même lorsqu'une exception se produit et également lorsque l'exception ne se produit pas.
Mais lorsque le bloc try se termine après le déclenchement de l'exception, nous ne pouvons pas placer ce code dans le bloc try. De même, le bloc catch a un gestionnaire d'exceptions, nous ne pouvons donc pas le mettre dans le bloc catch également.
Ainsi, nous avons besoin d'un bloc séparé contenant un code qui s'exécute indépendamment du fait qu'une exception se produise ou non. Java fournit un bloc «enfin» qui contient ce morceau de code.
Par conséquent, un bloc finally en Java peut contenir des instructions critiques qui doivent être exécutées dans le programme. L'exécution de ces instructions doit être effectuée même lorsqu'une exception se produit ou non.
Par conséquent, nous mettrons du code comme la fermeture des connexions, des objets de flux, etc. ou tout code de nettoyage dans le bloc finally afin qu'ils puissent être exécutés même si une exception se produit.
Le bloc finally en Java est généralement placé après un bloc try ou catch. Notez que le bloc finally ne peut pas exister sans un bloc try. Lorsque le bloc finally est inclus avec try-catch, il devient un ' essayer-attraper-enfin ' bloquer.
Nous pouvons ignorer le bloc finally dans le code de gestion des exceptions. Cela signifie que le bloc finally est facultatif.
Si le bloc try ne déclenche aucune exception, le bloc finally sera exécuté après le bloc try. S'il y a une exception dans le bloc try, alors le contrôle passera d'abord au bloc catch puis au bloc finally.
Une exception se produisant dans le bloc finally se comporte de la même manière que toute autre exception. Même si le bloc try contient une instruction return ou des instructions de branchement telles que break and continue, alors le bloc finally sera toujours exécuté.
En gardant ces points à l'esprit, allez-y avec la syntaxe générale et des exemples de finally block.
La syntaxe générale du bloc finally est la suivante:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Bien que le bloc finally soit toujours exécuté, il existe certaines situations ou cas dans lesquels il ne s’exécute pas.
Ce sont les cas ci-dessous:
- Quand le fil est mort.
- Lorsque la méthode System.exit () est utilisée.
- Lorsqu'une exception se produit dans le bloc finally.
Implémentons quelques programmes pour démontrer le blocage final.
class Main { public static void main (String args()) { //try block try { System.out.println ('::Try Block::'); int data = 125 / 5; System.out.println ('Result:' + data); } //catch block catch (NullPointerException e) { System.out.println ('::Catch Block::'); System.out.println (e); } //finally block finally { System.out.println (':: Finally Block::'); System.out.println ('No Exception::finally block executed'); } System.out.println ('rest of the code...'); } } Production
Le programme ci-dessus montre un bloc try-catch-finally. Dans le bloc try, une opération valide est effectuée et par conséquent aucune exception n'est levée. Par conséquent, le contrôle n'est pas passé pour catch from try mais pour finalement bloquer.
Le programme suivant est un autre exemple de bloc try-catch-finally mais dans ce cas, l'exception est levée dans le bloc try lorsque nous effectuons une opération de division par zéro. Ainsi, le bloc finally est exécuté après l'exécution du bloc try the catch.
class Main { public static void main(String args()) { //try block try{ System.out.println('::Try block::'); int num=67/0; System.out.println(num); } //catch block catch(ArithmeticException e){ System.out.println('::Catch block::'); System.out.println('ArithmeticException::Number divided by zero'); } //finally block finally{ System.out.println('::Finally block::'); } System.out.println('Rest of the code continues...'); } } Production
Lancer une exception en Java
Java fournit un mot-clé «throw» à l'aide duquel nous pouvons explicitement lancer les exceptions dans le code. Par exemple, si nous vérifions des opérations arithmétiques et que nous voulons lever des exceptions après avoir vérifié les opérandes, nous pouvons le faire en utilisant le mot-clé ‘throw’.
En utilisant le mot-clé throw, nous pouvons lever les exceptions cochées ou non cochées. Le mot clé throw est également utilisé pour lever des exceptions personnalisées.
La syntaxe générale du mot-clé throw est:
throw exception; or throw new exception_class('error message'); Vous trouverez ci-dessous un exemple de programme pour illustrer le mot-clé throw.
public class Main{ static void validate_Age(int age){ //if specified age is <18, throw ArithmeticException if(age<18) throw new ArithmeticException('Not eligible to vote and drive!!'); else //print the message System.out.println('Eligible to vote and drive!!'); } public static void main(String args()){ //call validate_Age method validate_Age(10); System.out.println('rest of the code...'); } } Production
Dans le programme ci-dessus, nous utilisons une méthode pour valider l'âge. Si l'âge est<18, then an exception is thrown to indicate the age is not valid.
Jette une clause
Nous avons vu try block pour déclarer des exceptions. Il contient le code qui peut déclencher des exceptions. Il existe une autre façon de déclarer une exception et il utilise le mot-clé «throws».
La déclaration d'exception utilisant le mot clé «throws» indique au programmeur qu'il peut y avoir une exception spécifiée après le mot clé «throws» et le programmeur doit fournir le code de gestionnaire correspondant pour cette exception afin de maintenir le déroulement normal du programme.
Cependant, la question se pose de savoir pourquoi nous avons besoin d'un mot-clé «throws» alors que nous avons un bloc try-catch plus fiable pour déclarer et gérer les exceptions?
L'une des raisons est qu'au fur et à mesure que le nombre d'exceptions susceptibles de se produire augmente, le nombre de blocs catch qui gère les exceptions augmente également car un bloc catch ne peut gérer qu'une seule exception.
De même, s'il existe de nombreuses méthodes dans un programme et que chaque méthode a de nombreuses exceptions, le code deviendra inutilement long et ingérable.
Ainsi, déclarer une exception avec le mot-clé throws dans la signature de la méthode, puis gérer l'appel de méthode à l'aide de try-catch semble être une solution viable.
Un autre avantage de la déclaration d'exceptions à l'aide du mot clé throws est que nous sommes obligés de gérer les exceptions. Si nous ne fournissons pas de gestionnaire pour une exception déclarée, le programme lèvera une erreur.
La syntaxe générale du mot clé throws est la suivante:
return_type method_name() throws exception_class_name{ //method code } Implémentons maintenant un programme Java pour illustrer le mot-clé «throws».
Dans ce programme, nous avons une classe Example_throw dans laquelle nous avons une méthode testMethod. Dans la signature de cette testMethod, nous déclarons deux exceptions IOException et Arithmetic Exception à l'aide du mot clé throws. Ensuite, dans la fonction main, les exceptions levées sont gérées par le bloc catch.
import java.io.*; class Example_Throw { //declare exception using throws in the method signature void testMethod(int num) throws IOException, ArithmeticException{ if(num==1) throw new IOException('IOException Occurred'); else throw new ArithmeticException('ArithmeticException'); } }class Main{ public static void main(String args()){ try{ //this try block calls the above method so handle the exception Example_Throw obj=new Example_Throw(); obj.testMethod(1); }catch(Exception ex){ System.out.println(ex); } } }Production
Questions fréquemment posées
Q # 1) Quand utiliser les lancers throw VS try-catch en Java?
Répondre: Le mot clé «throws» est utilisé pour déclarer l'exception avec la signature de méthode. Le mot clé throw est utilisé pour lever explicitement l'exception. Le bloc try-catch est utilisé pour gérer les exceptions levées par d'autres.
Q # 2) Pouvons-nous utiliser les lancers, essayer et attraper dans une seule méthode?
Répondre: Non. Vous ne pouvez pas lancer l'exception et l'attraper dans la même méthode. L'exception déclarée à l'aide de throws doit être gérée dans la méthode d'appel qui appelle la méthode qui a levé l'exception.
Q # 3) Que se passe-t-il lorsqu'un bloc catch lève une exception?
Répondre: Lorsqu'une exception est levée dans le bloc catch, le programme arrêtera l'exécution. Dans le cas où le programme doit continuer, il doit y avoir un bloc try-catch séparé pour gérer l'exception déclenchée dans le bloc catch.
Q # 4) Qu'est-ce que try-catch-finally en Java?
Répondre: Le bloc try-catch-finally contient les trois blocs, c'est-à-dire le bloc try, le bloc catch et le bloc finally.
Le bloc Try contient le code susceptible de lever une exception. Le bloc Catch contient le gestionnaire d'exceptions pour les exceptions dans le bloc try. Le bloc finally contient le code critique qui s'exécutera indépendamment du fait que l'exception se soit produite ou non.
Q # 5) Puis-je enfin bloquer un try-catch?
qu'est-ce que les tests d'acceptation des utilisateurs dans les tests logiciels
Répondre: Oui, si nous avons un code de nettoyage qui pourrait lever une exception dans le bloc finally, alors nous pouvons avoir un bloc try-catch. Cependant, ça a l'air moche.
Conclusion
Dans ce didacticiel, nous avons abordé les différents mots-clés utilisés dans la gestion des exceptions en Java. Nous avons discuté des mots-clés comme essayer, attraper, enfin, lancer et lancer.
Le code qui lèvera éventuellement une exception est inclus dans le bloc try et catch fournit le gestionnaire de l'exception. Le bloc finally exécute le code qu'il contient, que l'exception soit levée ou non. Le bloc finally suit généralement le bloc try ou try-catch.
Nous utilisons le mot clé throws pour déclarer des exceptions avec la signature de méthode et throw est utilisé explicitement pour lever des exceptions. Nous utilisons généralement le mot clé throw pour lancer des exceptions personnalisées.
=> Consultez le guide de formation Perfect Java ici.
lecture recommandée
- Exceptions Java et gestion des exceptions avec des exemples
- Comment gérer l'exception ArrayIndexOutOfBoundsException en Java?
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- Gestion des exceptions JDBC - Comment gérer les exceptions SQL
- Tutoriel sur la gestion des exceptions C # avec des exemples de code
- Guide complet de la gestion des exceptions PL SQL avec des exemples
- Gestion des exceptions en C ++
- Python Try Except - Exception de gestion de Python avec des exemples