Gestion des exceptions Java

Les exceptions sont des erreurs dans le programme, mais toutes les erreurs ne sont pas des exceptions, et les erreurs peuvent parfois être évitées.

Par exemple, s'il manque un point-virgule dans votre code, le résultat sera une erreur java.lang.Error; si vous utilisez System.out.println(11/0), alors vous l'êtes parce que si vous utilisez 0 comme diviseur, une java.lang.ArithmeticException sera levée.

Il existe de nombreuses raisons d'exceptions, qui incluent généralement les catégories suivantes :

• L'utilisateur a saisi des données illégales.

• Le fichier à ouvrir n'existe pas.

• La connexion est interrompue pendant la communication réseau ou la mémoire JVM déborde.

Certaines de ces exceptions sont causées par des erreurs d'utilisateur, certaines sont causées par des erreurs de programme et d'autres sont causées par des erreurs physiques. -

Pour comprendre le fonctionnement de la gestion des exceptions Java, vous devez maîtriser les trois types d'exceptions suivants :

• Exceptions vérifiées : Les exceptions vérifiées les plus représentatives sont les exceptions causées par des erreurs ou des problèmes de l'utilisateur, qui ne peuvent pas être prévus par le programmeur. Par exemple, lorsque vous essayez d'ouvrir un fichier qui n'existe pas, une exception se produit. Ces exceptions ne peuvent pas être simplement ignorées au moment de la compilation.

• Exceptions d'exécution : Les exceptions d'exécution sont des exceptions qui peuvent être évitées par le programmeur. Contrairement aux exceptions vérifiées, les exceptions d'exécution peuvent être ignorées au moment de la compilation.

• Erreur : Une erreur n'est pas une exception, mais un problème indépendant de la volonté du programmeur. Les erreurs sont souvent ignorées dans le code. Par exemple, lorsque la pile déborde, une erreur se produit qui ne peut pas être vérifiée lors de la compilation.

Hiérarchie des classes d'exception

Toutes les classes d'exception sont des sous-classes héritées de la classe java.lang.Exception.

La classe Exception est une sous-classe de la classe Throwable. En plus de la classe Exception, Throwable possède également une sous-classe Error.

Les programmes Java ne détectent généralement pas les erreurs. Les erreurs se produisent généralement lorsque des pannes graves surviennent et elles sortent du cadre du traitement par les programmes Java.

L'erreur est utilisée pour indiquer les erreurs qui se produisent dans l'environnement d'exécution.

Par exemple, débordement de mémoire JVM. Normalement, les programmes ne récupèrent pas des erreurs.

La classe d'exception a deux sous-classes principales : la classe IOException et la classe RuntimeException.

Dans les classes intégrées Java (expliquées ci-après), les exceptions cochées et non cochées sont les plus couramment utilisées.

Classes d'exceptions intégrées à Java

Le langage Java définit certaines classes d'exceptions dans le package standard java.lang.

Les sous-classes des classes d'exceptions d'exécution standard sont les classes d'exceptions les plus courantes. Étant donné que le package java.lang est chargé par défaut dans tous les programmes Java, la plupart des exceptions héritées de la classe d'exception d'exécution peuvent être utilisées directement.

Java définit également d'autres exceptions basées sur chaque bibliothèque de classes. Le tableau suivant répertorie les exceptions non vérifiées de Java.

Le tableau suivant répertorie les classes d'exceptions cochées Java définies dans le package java.lang.

Méthodes d'exception

La liste suivante est la méthode principale de la classe Throwable :

Détecter les exceptions

Utilisez les mots-clés try et catch pour détecter les exceptions. Les blocs de code Try/Catch sont placés là où des exceptions peuvent survenir.

Le code dans le bloc de code try/catch est appelé code de garde. La syntaxe d'utilisation de try/catch est la suivante :

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

L'instruction Catch contient une déclaration du type d'exception à être. attrapé. Lorsqu'une exception se produit dans le bloc de code protégé, le bloc catch suivant le try sera vérifié.

Si l'exception qui se produit est contenue dans un bloc catch, l'exception sera transmise au bloc catch, ce qui revient à passer un paramètre à une méthode.

Exemple

L'exemple suivant déclare un tableau avec deux éléments Lorsque le code tente d'accéder au troisième élément du tableau, une exception sera levée.

// 文件名 : ExcepTest.java
import java.io.*;
public class ExcepTest{

   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

Le résultat de la compilation et de l'exécution du code ci-dessus est le suivant :

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Plusieurs blocs catch

Un bloc de code try suivi de plusieurs blocs de code catch est appelé capture de plusieurs blocs de capture.

La syntaxe de plusieurs blocs catch est la suivante :

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }

L'extrait de code ci-dessus contient 3 blocs catch.

Vous pouvez ajouter n'importe quel nombre de blocs catch après l'instruction try.

Si une exception se produit dans le code protégé, l'exception est levée vers le premier bloc catch.

Si le type de données de l'exception levée correspond à ExceptionType1, elle sera interceptée ici.

S'il n'y a pas de correspondance, elle est transmise au deuxième bloc catch.

Ceci est fait jusqu'à ce que l'exception soit interceptée ou passe tous les blocs catch.

Exemple

Cet exemple montre comment utiliser plusieurs try/catch.

try
{
   file = new FileInputStream(fileName);
   x = (byte) file.read();
}catch(IOException i)
{
   i.printStackTrace();
   return -1;
}catch(FileNotFoundException f) //Not valid!
{
   f.printStackTrace();
   return -1;
}

throws/throw mot-clé :

Si une méthode n'attrape pas une exception vérifiée, alors la méthode doit être déclarée à l'aide du mot-clé throws. Le mot-clé throws est placé à la fin de la signature de la méthode.

Vous pouvez également utiliser le mot-clé throw pour lancer une exception, qu'elle soit nouvellement instanciée ou juste interceptée.

La déclaration de méthode suivante lève une RemoteException :

import java.io.*;
public class className
{
   public void deposit(double amount) throws RemoteException
   {
      // Method implementation
      throw new RemoteException();
   }
   //Remainder of class definition
}

Une méthode peut déclarer plusieurs exceptions, séparées par des virgules.

Par exemple, la déclaration de méthode suivante renvoie RemoteException et InsufficientFundsException :

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

finally le mot-clé

finally le mot-clé est utilisé pour créer un bloc de code try qui s'exécute après le code bloc.

Peu importe qu'une exception se produise ou non, le code du bloc de code final sera toujours exécuté.

Dans le bloc de code enfin, vous pouvez exécuter des instructions de nettoyage et d'autres instructions de nettoyage. Le bloc de code

finally apparaît à la fin du bloc de code catch, et la syntaxe est la suivante :

 try{
    // 程序代码
 }catch(异常类型1 异常的变量名1){
    // 程序代码
 }catch(异常类型2 异常的变量名2){
    // 程序代码
 }finally{
    // 程序代码
 }

Exemple

 public class ExcepTest{

   public static void main(String args[]){
      int a[] = new int[2];
      try{
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      finally{
         a[0] = 6;
         System.out.println("First element value: " +a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

La compilation et l'exécution des résultats de ce qui précède exemple sont les suivants :

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Notez le sujet suivant :

• catch ne peut pas exister indépendamment de try.

• Il n'est pas obligatoire d'ajouter un bloc final après try/catch.

• Il ne peut y avoir ni bloc catch ni bloc final après le code try.

• Aucun code ne peut être ajouté entre les blocs try, catch et enfin.

Déclarer des exceptions personnalisées

En Java, vous pouvez définir des exceptions personnalisées. Il y a quelques points à garder à l’esprit lorsque vous écrivez vos propres classes d’exceptions.

• Toutes les exceptions doivent être des sous-classes de Throwable.

• Si vous souhaitez écrire une classe d'exception vérifiée, vous devez hériter de la classe Exception.

• Si vous souhaitez écrire une classe d'exceptions d'exécution, vous devez hériter de la classe RuntimeException.

Vous pouvez définir votre propre classe d'exception comme suit :

class MyException extends Exception{
}

La classe d'exception créée en héritant uniquement de la classe Exception est une classe d'exception vérifiée.

La classe InsufficientFundsException suivante est une classe d'exception définie par l'utilisateur qui hérite d'Exception.

Une classe d'exception, comme toute autre classe, contient des variables et des méthodes.

Exemple

// 文件名InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception
{
   private double amount;
   public InsufficientFundsException(double amount)
   {
      this.amount = amount;
   } 
   public double getAmount()
   {
      return amount;
   }
}

Pour montrer comment utiliser notre classe d'exception personnalisée,

Incluez une méthode Remove() dans la classe CheckingAccount ci-dessous pour lever une exception InsufficientFundsException.

// 文件名称 CheckingAccount.java
import java.io.*;

public class CheckingAccount
{
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
   public void deposit(double amount)
   {
      balance += amount;
   }
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   public double getBalance()
   {
      return balance;
   }
   public int getNumber()
   {
      return number;
   }
}

Le programme BankDemo suivant montre comment appeler les méthodes deposit() et Remove() de la classe CheckingAccount.

//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing 0...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing 0...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing 0...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}

Compilez les trois fichiers ci-dessus et exécutez le programme BankDemo Le résultat est le suivant :

Depositing 0...

Withdrawing 0...

Withdrawing 0...
Sorry, but you are short 0.0
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

Exception générale

Il existe deux types définis dans les exceptions Java. et les erreurs.

• JVM (JavaMachine virtuelle)Exception : Exception levée par JVM ou erreur . Par exemple : classe NullPointerException, classe ArrayIndexOutOfBoundsException, classe ClassCastException.

• Exception au niveau du programme : Exception levée par un programme ou un programme API. Par exemple, classe IllegalArgumentException, classe IllegalStateException.