1. Gestion des exceptions
2. Avantage de la gestion des exceptions
3. Hiérarchie des classes d'exception
4. Types d'exceptions
5. Exemple d'exception
6. Scénarios où une exception peut se produire

Le Gestion des exceptions en Java est l'un des puissants mécanisme pour gérer les erreurs d'exécution afin que le flux normal de l'application puisse être maintenu.

Dans ce didacticiel, nous découvrirons les exceptions Java, leurs types et la différence entre les exceptions cochées et non cochées.

thread.destroy

Qu’est-ce qu’une exception en Java ?

Signification du dictionnaire : L'exception est une condition anormale.

En Java, une exception est un événement qui perturbe le déroulement normal du programme. C'est un objet qui est lancé au moment de l'exécution.

Qu’est-ce que la gestion des exceptions ?

La gestion des exceptions est un mécanisme permettant de gérer les erreurs d'exécution telles que ClassNotFoundException, IOException, SQLException, RemoteException, etc.

Avantage de la gestion des exceptions

Le principal avantage de la gestion des exceptions est pour maintenir le flux normal de l'application . Une exception perturbe normalement le flux normal de l'application ; c'est pourquoi nous devons gérer les exceptions. Considérons un scénario :

 statement 1; statement 2; statement 3; statement 4; statement 5;//exception occurs statement 6; statement 7; statement 8; statement 9; statement 10; 

Supposons qu'il y ait 10 instructions dans un programme Java et qu'une exception se produise à l'instruction 5 ; le reste du code ne sera pas exécuté, c'est-à-dire que les instructions 6 à 10 ne seront pas exécutées. Cependant, lorsque nous effectuons la gestion des exceptions, le reste des instructions sera exécuté. C'est pourquoi nous utilisons la gestion des exceptions dans Java .

Hiérarchie des classes d'exception Java

La classe java.lang.Throwable est la classe racine de la hiérarchie Java Exception héritée de deux sous-classes : Exception et Error. La hiérarchie des classes d'exception Java est indiquée ci-dessous :

Types d'exceptions Java

Il existe principalement deux types d’exceptions : cochées et non cochées. Une erreur est considérée comme une exception non vérifiée. Cependant, selon Oracle, il existe trois types d'exceptions à savoir :

1. Exception vérifiée
2. Exception non vérifiée
3. Erreur

Différence entre les exceptions cochées et non cochées

1) Exception vérifiée

Les classes qui héritent directement de la classe Throwable, à l'exception de RuntimeException et Error, sont appelées exceptions vérifiées. Par exemple, IOException, SQLException, etc. Les exceptions vérifiées sont vérifiées au moment de la compilation.

2) Exception non vérifiée

Les classes qui héritent de RuntimeException sont appelées exceptions non contrôlées. Par exemple, ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, etc. Les exceptions non vérifiées ne sont pas vérifiées au moment de la compilation, mais elles sont vérifiées au moment de l'exécution.

3) Erreur

L'erreur est irrécupérable. Quelques exemples d'erreurs sont OutOfMemoryError, VirtualMachineError, AssertionError etc.

Mots clés d'exception Java

Java fournit cinq mots-clés utilisés pour gérer l'exception. Le tableau suivant décrit chacun.

Exemple de gestion des exceptions Java

Voyons un exemple de gestion des exceptions Java dans lequel nous utilisons une instruction try-catch pour gérer l'exception.

JavaExceptionExample.java

 public class JavaExceptionExample{ public static void main(String args[]){ try{ //code that may raise exception int data=100/0; }catch(ArithmeticException e){System.out.println(e);} //rest code of the program System.out.println('rest of the code...'); } } 

Sortir:

 Exception in thread main java.lang.ArithmeticException:/ by zero rest of the code... 

Dans l'exemple ci-dessus, 100/0 déclenche une ArithmeticException qui est gérée par un bloc try-catch.

Scénarios courants d'exceptions Java

Certains scénarios sont présentés dans lesquels des exceptions non contrôlées peuvent se produire. Ils sont les suivants :

1) Un scénario dans lequel ArithmeticException se produit

Si nous divisons un nombre par zéro, une ArithmeticException se produit.

 int a=50/0;//ArithmeticException 

2) Un scénario dans lequel NullPointerException se produit

Si nous avons une valeur nulle dans n'importe quel variable , effectuer toute opération sur la variable lève une NullPointerException.

 String s=null; System.out.println(s.length());//NullPointerException 

3) Un scénario dans lequel NumberFormatException se produit

Si le formatage d'une variable ou d'un nombre ne correspond pas, cela peut entraîner une exception NumberFormatException. Supposons que nous ayons un chaîne variable contenant des caractères ; la conversion de cette variable en chiffre provoquera NumberFormatException.

 String s='abc'; int i=Integer.parseInt(s);//NumberFormatException 

4) Un scénario dans lequel ArrayIndexOutOfBoundsException se produit

Lorsqu'un tableau dépasse sa taille, l'exception ArrayIndexOutOfBoundsException se produit. il peut y avoir d'autres raisons pour lesquelles ArrayIndexOutOfBoundsException se produit. Considérez les déclarations suivantes.

 int a[]=new int[5]; a[10]=50; //ArrayIndexOutOfBoundsException 

Index des exceptions Java

1. Bloc Java Try-Catch
2. Bloc de capture multiple Java
3. Essai imbriqué Java
4. Java enfin bloquer
5. Java lancer le mot-clé
6. Propagation des exceptions Java
7. Java lance un mot-clé
8. Java lancer vs lancers
9. Java Final vs Enfin vs Finaliser
10. Gestion des exceptions Java avec remplacement de méthode
11. Exceptions personnalisées Java