Gestion des exceptions dans Java

Qu'est-ce que l'exception dans Java?

Exception dans Java est un événement qui interrompt l'exécution des instructions du programme et perturbe le flux normal de l'exécution du programme. Il s'agit d'un objet qui encapsule les informations d'un événement d'erreur survenu dans une méthode et qui est transmis au système d'exécution. Dans Java, les exceptions sont principalement utilisées pour indiquer différents types de conditions d'erreur.

Il existe deux types d'erreurs :

Erreurs de temps de compilation
Erreurs d'exécution

Les erreurs de compilation peuvent à nouveau être classées en deux types :

Erreurs de syntaxe
Erreurs sémantiques

Exemple d'erreurs de syntaxe :

Au lieu de déclarer int a; vous l'avez déclaré par erreur comme in a; pour lequel le compilateur générera une erreur.

Exemple : Vous avez déclaré une variable int a; et après quelques lignes de code, vous déclarez à nouveau un entier comme int a;Toutes ces erreurs sont mises en évidence lorsque vous compilez le code.

Exemple d'erreurs d'exécution

Une erreur d'exécution est appelée un Exceptions erreur. Il s'agit de tout événement qui interrompt le déroulement normal de l'exécution du programme. Les exemples d'exceptions sont les exceptions arithmétiques, les exceptions Nullpointer, les exceptions Divide by zero, etc. Les exceptions dans Java sont quelque chose qui échappe au contrôle des développeurs.

Cliquez sur ici si la vidéo n'est pas accessible

Pourquoi avons-nous besoin d’une exception ?

Supposons que vous ayez codé un programme pour accéder au serveur. Les choses ont bien fonctionné pendant que vous développiez le code.

Pendant la production réelle, le serveur est en panne. Lorsque votre programme tente d'y accéder, une exception est levée.

Comment gérer les exceptions

Jusqu'à présent, nous l'avons vu, les exceptions échappent au contrôle du développeur. Mais imputer l’échec de votre code aux problèmes environnementaux n’est pas une solution. Vous avez besoin d’une programmation robuste, qui prend en charge les situations exceptionnelles. Un tel code est connu sous le nom de Gestionnaire d'exceptions.

Dans notre exemple, une bonne gestion des exceptions consisterait, lorsque le serveur est en panne, à se connecter au serveur de sauvegarde.

Pour mettre cela en œuvre, entrez votre code pour vous connecter au serveur (en utilisant les conditions traditionnelles if et else). Vous vérifierez si le serveur est en panne. Si oui, écrivez le code pour vous connecter au serveur de sauvegarde. Une telle organisation du code, utilisant des boucles « if » et « else », n’est pas efficace lorsque votre code comporte plusieurs exceptions Java gérer.

class connect{
	if(Server Up){
	 // code to connect to server
	}
	else{
	 // code to connect to BACKUP server
	}
}

Essayez le bloc Catch

Java offre une maniabilité exceptionnelle intégrée.

Le code normal entre dans un TRY bloque.
Le code de gestion des exceptions va dans le CAPTURE bloc

Dans notre exemple, le bloc TRY contiendra le code de connexion au serveur. Le bloc CATCH contiendra le code de connexion au serveur de secours. Si le serveur est opérationnel, le code du bloc CATCH sera ignoré. Si le serveur est en panne, une exception est levée et le code du bloc catch sera exécuté.

Voici donc comment l'exception est gérée dans Java.

Syntaxe d'utilisation de try & catch

try{
    statement(s)
}
catch (exceptiontype name){
	statement(s)
}

Exemple

Étape 1) Copiez le code suivant dans un éditeur

class JavaException {
   public static void main(String args[]){
      int d = 0;
      int n = 20;
      int fraction = n/d;
     System.out.println("End Of Main");
   }
}

Étape 2) Enregistrez le fichier et compilez le code. Exécutez le programme à l'aide de la commande java JavaException

Étape 3) Une exception arithmétique – la division par zéro est affichée comme ci-dessous pour la ligne n° 5 et la ligne n° 6 n'est jamais exécutée

Étape 4) Voyons maintenant comment try and catch nous aidera à gérer cette exception. Nous mettrons l'exception provoquant la ligne de code dans un Essai bloc, suivi d'un capture bloc. Copiez le code suivant dans l'éditeur.

class JavaException {
 public static void main(String args[]) {
  int d = 0;
  int n = 20;
  try {
   int fraction = n / d;
   System.out.println("This line will not be Executed");
  } catch (ArithmeticException e) {
   System.out.println("In the catch Block due to Exception = " + e);
  }
  System.out.println("End Of Main");
 }
}

Étape 5) Enregistrez, compilez et exécutez le code. Vous obtiendrez le résultat suivant

Comme vous le constatez, l'exception est gérée et la dernière ligne de code est également exécutée. Notez également que la ligne n°7 ne sera pas exécutée car dès qu'une exception est levée, le flux de contrôle passe au bloc catch.

Attention: L'objet AritmeticException « e » contient des informations sur l'exception qui s'est produite, ce qui peut être utile pour prendre des mesures de récupération.

Java Hiérarchie des classes d'exception

Après l'exécution d'une instruction catch, les autres sont contournées et l'exécution continue après le bloc try/catch. Les blocs catch imbriqués suivent la hiérarchie des exceptions.

Toutes les classes d'exception dans Java étendre la classe 'Throwable'. Throwable a deux sous-classes, Error et Exception
La classe Error définit l'exception ou les problèmes qui ne devraient pas se produire dans des circonstances normales par notre programme, par exemple erreur de mémoire, erreur matérielle, erreur JVM, etc.
La classe Exception représente les exceptions qui peuvent être gérées par notre programme, et notre programme peut être récupéré à partir de cette exception en utilisant le bloc try and catch
Une exception d'exécution est une sous-classe de la classe d'exception. L'exception de ce type représente une exception qui se produit au moment de l'exécution et qui ne peut pas être suivie au moment de la compilation. Un excellent exemple de ce type est l'exception de division par zéro, l'exception de pointeur nul, etc.
Une exception IO est générée lors des opérations d'entrée et de sortie
Exceptions interrompues dans Java, est généré lors de plusieurs threads.

Mise en situation : Pour comprendre l'imbrication des blocs try and catch

Étape 1) Copiez le code suivant dans un éditeur.

class JavaException {
 public static void main(String args[]) {
  try {
   int d = 1;
   int n = 20;
   int fraction = n / d;
   int g[] = {
    1
   };
   g[20] = 100;
  }
  /*catch(Exception e){
  	System.out.println("In the catch block due to Exception = "+e);
  }*/
  catch (ArithmeticException e) {
   System.out.println("In the catch block due to Exception = " + e);
  } catch (ArrayIndexOutOfBoundsException e) {
   System.out.println("In the catch block due to Exception = " + e);
  }
  System.out.println("End Of Main");
 }
}

Étape 2) Enregistrez le fichier et compilez le code. Exécutez le programme à l'aide de la commande, Java JavaException.

Étape 3) Une ArrayIndexOutOfBoundsException est générée. Modifiez la valeur de int d à 0. Enregistrez, compilez et exécutez le code.

Étape 4) Une ArithmeticException doit être générée.

Étape 5) Décommentez la ligne n°10 en ligne n°12. Enregistrez, compilez et exécutez le code.

Étape 6) Erreur de compilation? En effet, Exception est la classe de base d’ArithmeticException Exception. Toute exception déclenchée par ArithmeticException peut également être gérée par la classe Exception. Ainsi, le bloc catch d'ArithmeticException n'aura jamais la chance d'être exécuté, ce qui le rend redondant. D'où l'erreur de compilation.

Java Enfin bloquer

Le bloc final est exécuté indépendamment de la levée d’une exception dans le bloc try. C'est facultatif à utiliser avec un bloc try.

 try {
  statement(s)
 } catch (ExceptiontType name) {

  statement(s)

 } finally {

  statement(s)

 }

Dans le cas où une exception est déclenchée dans le bloc try, le bloc final est exécuté après l'exécution du bloc catch.

Exemple

Étape 1) Copiez le code suivant dans un éditeur.

class JavaException {
   public static void main(String args[]){
    try{
       int d = 0;
       int n =20;
       int fraction = n/d;
    }
  catch(ArithmeticException e){
    System.out.println("In the catch block due to Exception = "+e);
  }
  finally{
	System.out.println("Inside the finally block");
  }
}
}

Étape 2) Enregistrez, compilez et exécutez le code.

Étape 3) Production attendue. Enfin, le bloc est exécuté même si une exception est levée.

Étape 4) Modifiez la valeur de la variable d = 1. Enregistrez, compilez et exécutez le code et observez le résultat.Bas du formulaire

Résumé

An L'exception est une erreur d'exécution qui interrompt le flux normal de l’exécution du programme. Une perturbation pendant l’exécution du programme est appelée erreur ou exception.
Les erreurs sont classées en deux catégories
- Erreurs de compilation – Erreurs de syntaxe, erreurs sémantiques
- Erreurs d'exécution - Exception
A un programme robuste devrait gérer toutes les exceptions et continuer son flux normal d'exécution du programme. Java fournit une méthode de manipulation exceptionnelle intégrée
Le gestionnaire d'exceptions est un ensemble de codes qui gère une exception. Les exceptions peuvent être traitées dans Java en utilisant try & catch.
Essayez de bloquer: Le code normal va sur ce bloc.
Bloc de capture: S'il y a une erreur dans le code normal, alors il ira dans ce bloc

Tu pourrais aimer: