Gestion des exceptions Java

En Java, la gestion des exceptions est un concept de programmation important utilisé pour gérer les erreurs ou les conditions exceptionnelles qui peuvent survenir lors de l'exécution d'un programme.

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

Par exemple, si votre code manque un point-virgule, alors la sortie est un message d'erreurjava.lang.Error, si vous utilisezSystem.out.println(11/0), alors comme vous utilisez0comme diviseur, cela lancerajava.lang.ArithmeticExceptionune exception.

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

  • L'utilisateur a saisi des données invalides.
  • Le fichier à ouvrir n'existe pas.
  • La connexion est interrompue pendant la communication réseau, ou la mémoire de la JVM déborde.

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

Pour comprendre comment fonctionne la gestion des exceptions en 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 celles causées par des erreurs ou des problèmes de l'utilisateur. Ces exceptions obligent les programmeurs à les gérer au moment de la compilation. Par exemple, lorsqu'on essaie d'ouvrir un fichier inexistant, une exception se produit, et ces exceptions ne peuvent pas être simplement ignorées au moment de la compilation.

    Ce type d'exception est généralement géré à l'aide de blocs de typetry-catchpour intercepter et gérer l'exception, ou à l'aide de clausesthrowspour déclarer les exceptions qu'une méthode peut lever.

    try {
    // 可能会抛出异常的代码
} catch (IOException e) {
    // 处理异常的代码
}

    Ou :

    public void readFile() throws IOException {
    // 可能会抛出IOException的代码
}

  • Exceptions d'exécution :Ces exceptions ne sont pas tenues d'être gérées au moment de la compilation ; elles sont généralement causées par des erreurs dans le programme, telles que NullPointerException, ArrayIndexOutOfBoundsException, etc. Ce type d'exception peut être géré de manière facultative, mais ce n'est pas obligatoire.

    try {
    // 可能会抛出异常的代码
} catch (NullPointerException e) {
    // 处理异常的代码
}

  • Erreurs :Les erreurs ne sont pas des exceptions, mais des problèmes hors du contrôle du programmeur. Les erreurs sont généralement ignorées dans le code. Par exemple, lorsqu'un débordement de pile se produit, une erreur survient, et elles ne peuvent pas non plus être détectées au moment de la compilation.

Java fournit les mots-clés et classes suivants pour prendre en charge la gestion des exceptions :

  • try: Utilisé pour encapsuler un bloc de code susceptible de lever une exception.
  • catch: Utilisé pour intercepter les exceptions et les gérer dans un bloc de code.
  • finally: Utilisé pour contenir un bloc de code qui doit être exécuté, qu'une exception se produise ou non.
  • throw: Utilisé pour lever une exception manuellement.
  • throws: Utilisé pour spécifier dans la déclaration d'une méthode les exceptions que la méthode peut lever.
  • La classe Exception: elle est la classe parente de toutes les classes d'exception et fournit des méthodes pour obtenir des informations sur l'exception, telles quegetMessage()、printStackTrace()etc.

Hiérarchie de la classe 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 n'attrapent généralement pas les erreurs. Les erreurs se produisent généralement lors de défaillances graves et sont en dehors du domaine de traitement des programmes Java.

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

Par exemple, un débordement de mémoire de la JVM. Généralement, les programmes ne peuvent pas se remettre des erreurs.

La classe Exception a deux sous-classes principales : la classe IOException et la classe RuntimeException.

Parmi les classes intégrées de Java (expliquées plus tard), on trouve la plupart des exceptions courantes vérifiées et non vérifiées.

Classes d'exception intégrées de Java

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

Les sous-classes de la classe standard d'exception d'exécution sont les classes d'exception 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 des classes d'exception d'exécution peuvent être utilisées directement.

Java définit également d'autres exceptions en fonction de diverses bibliothèques de classes. Le tableau suivant répertorie les exceptions non vérifiées de Java.

Exception Description
ArithmeticException Levée lorsqu'une condition arithmétique exceptionnelle se produit. Par exemple, lorsqu'un entier est divisé par zéro, une instance de cette classe est levée.
ArrayIndexOutOfBoundsException Exception levée lors de l'accès à un tableau avec un index illégal. Si l'index est négatif ou supérieur ou égal à la taille du tableau, l'index est illégal.
ArrayStoreException Exception levée lors de la tentative de stockage d'un objet du mauvais type dans un tableau d'objets.
ClassCastException Levée lors de la tentative de conversion d'un objet en une sous-classe dont il n'est pas une instance.
IllegalArgumentException Levée pour indiquer qu'un argument illégal ou inapproprié a été passé à une méthode.
IllegalMonitorStateException Levée pour indiquer qu'un thread a tenté d'attendre sur le moniteur d'un objet, ou de notifier d'autres threads en attente sur le moniteur d'un objet, sans posséder lui-même le moniteur.
IllegalStateException Signale qu'une méthode a été invoquée à un moment illégal ou inapproprié. En d'autres termes, l'environnement Java ou l'application Java n'est pas dans l'état approprié requis pour l'opération demandée.
IllegalThreadStateException Exception levée lorsqu'un thread n'est pas dans l'état approprié requis pour l'opération demandée.
IndexOutOfBoundsException Levée pour indiquer qu'un certain type d'index (comme pour un tableau, une chaîne ou un vecteur) est en dehors des limites.
NegativeArraySizeException Levée si une application tente de créer un tableau avec une taille négative.
NullPointerException Lorsqu'une application tente d'utilisernullà un endroit où un objet est requis, cette exception est levée.
NumberFormatException Levée lorsqu’une application tente de convertir une chaîne en un type numérique, mais que la chaîne ne peut pas être convertie au format approprié.
SecurityException Une exception levée par le gestionnaire de sécurité pour indiquer une violation de sécurité.
StringIndexOutOfBoundsException Cette exception est levée parStringla méthode pour indiquer que l’index est soit négatif, soit supérieur à la taille de la chaîne.
UnsupportedOperationException Levée lorsque l’opération demandée n’est pas prise en charge.

Le tableau suivant répertorie les classes d’exceptions vérifiées définies par Java dans le package java.lang.

Exception Description
ClassNotFoundException Levée lorsqu’une application tente de charger une classe mais ne trouve pas la classe correspondante.
CloneNotSupportedException Lors de l'appelObjectla méthode dans lacloneclasse pour cloner un objet, mais la classe de l'objet ne peut pas implémenterCloneablel'interface, cette exception est levée.
IllegalAccessException Levée lorsqu'un accès à une classe est refusé.
InstantiationException Lorsque l'on essaie d'utiliserClassla méthode dans lanewInstancela classe pour créer une instance d'une classe, mais l'objet de classe spécifié ne peut pas être instancié car il s'agit d'une interface ou d'une classe abstraite, cette exception est levée.
InterruptedException Levée lorsqu'un thread est interrompu par un autre thread.
NoSuchFieldException La variable demandée n'existe pas.
NoSuchMethodException La méthode demandée n'existe pas.

Méthodes d'exception

La liste suivante présente les principales méthodes de la classe Throwable :

Non. Méthode et description
1 public String getMessage()
Retourne des informations détaillées sur l'exception qui s'est produite. Ce message est initialisé dans le constructeur de la classe Throwable.
2 public Throwable getCause()
Retourne un objet Throwable représentant la cause de l'exception.
3 public String toString()
Retourne une brève description de ce Throwable.
4 public void printStackTrace()
Affiche ce Throwable et sa trace d'appels sur le flux d'erreur standard.
5 public StackTraceElement [] getStackTrace()
Renvoie un tableau contenant la trace de pile. L'élément à l'index 0 représente le sommet de la pile, et le dernier élément représente le bas de la pile d'appels de méthodes.
6 public Throwable fillInStackTrace()
Remplit la trace de pile de l'objet Throwable avec la trace de pile d'appels actuelle, en ajoutant aux éventuelles informations précédentes de la trace de pile.

Intercepter les exceptions

Utilisez les mots-clés try et catch pour intercepter des exceptions. Le bloc de code try/catch est placé là où une exception peut se produire.

Le code à l'intérieur d'un bloc de code try/catch est appelé code protégé. La syntaxe d'utilisation de try/catch est la suivante :

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

La clause catch contient une déclaration du type d'exception à intercepter. Lorsqu'une exception se produit dans le bloc de code protégé, le bloc catch qui suit le try est vérifié.

Si l'exception qui se produit est incluse dans le bloc catch, l'exception est transmise à ce bloc catch, de la même manière qu'une méthode transmet un argument.

Exemple

Dans l'exemple suivant, un tableau à deux éléments est déclaré. Lorsque le code tente d'accéder au quatrième élément du tableau, une exception est levée.

Code du fichier ExcepTest.java :

//Nom du fichier : ExcepTest.java import java.io.*; public class ExcepTest{ public static void main(String args[]){ try{ int a[] = new int[2]; System.out.println("Accéder à l'élément trois :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception levée :" + e); } System.out.println("Hors du bloc"); } }

La sortie de la compilation et de l'exécution du code ci-dessus est la suivante :

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

Blocs catch multiples

La situation où un bloc try est suivi de plusieurs blocs catch est appelée capture multiple.

La syntaxe pour plusieurs blocs catch est la suivante :

try{ //code }catch(type d'exception1nom de variable d'exception1){ //code }catch(type d'exception2nom de la variable d'exception2){ //code }catch(type d'exception3nom de la variable d'exception3){ //code }

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

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

Si une exception se produit dans le code protégé, l'exception est transmise au premier bloc catch.

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

S'il ne correspond pas, il est transmis au deuxième bloc catch.

Et ainsi de suite, jusqu'à ce que l'exception soit interceptée ou qu'elle traverse tous les blocs catch.

Exemple

Cet exemple montre comment utiliser plusieurs try/catch.

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

Multi-catch pour plusieurs exceptions

À partir de Java 7, une syntaxe plus concise a été introduite — la capture combinée de plusieurs exceptions, qui permet à un seul bloc catch de gérer plusieurs exceptions n'ayant aucune relation d'héritage entre elles.

try {
    // 可能抛出多个不同类型异常的代码
} catch (异常类型1 | 异常类型2 | 异常类型3 异常变量) {
    // 统一处理
}

Remarque :

  • ExceptionType1, ExceptionType2, etc. ne peuvent pas avoir de relation d'héritage ; sinon, une erreur de compilation se produira.
  • Le nom de la variable d'exception est une variable de référence commune pour ces exceptions, vous ne pouvez donc pas appeler leurs méthodes spécifiques à l'intérieur du bloc catch.
  • Le compilateur déduit que le type de cette variable d'exception est la superclasse commune la plus proche de ces exceptions (comme Exception ou IOException).

Comme dans ce qui suit, où les exceptions n'héritent pas les unes des autres et où SQLException et IOException peuvent toutes deux être levées :

Exemple

try {
    // Les exceptions SQL et IO peuvent toutes deux être levées
    doSomething();
} catch (SQLException | IOException e) {
    System.out.println("Une exception SQL ou IO s'est produite !");
    e.printStackTrace();
}

Exemple incorrect (impossible de combiner des exceptions de classes parent-enfant) :

// 错误写法！
catch (FileNotFoundException | IOException e) {
    // 会导致编译错误，因为 FileNotFoundException 是 IOException 的子类
}

FileNotFoundException est une sous-classe de IOException, donc cette approche est en fait illégale et provoquera une erreur de compilation.

Mots-clés throws/throw

En Java,throwetthrowsles mots-clés sont utilisés pour gérer les exceptions.

throwLe mot-clé est utilisé pour lever une exception dans le code, tandis quethrowsle mot-clé est utilisé dans la déclaration de méthode pour spécifier les types d'exceptions qui peuvent être levées.

Mot-clé throw

throwLe mot-clé est utilisé pour lever une exception dans la méthode courante.

Normalement, lorsque le code atteint une condition dans laquelle il ne peut pas poursuivre une exécution normale, vous pouvez utiliserthrowle mot-clé pour lever une exception, afin d'informer l'appelant de l'état d'exécution actuel du code.

Par exemple, dans le code suivant, la méthode vérifie si num est inférieur à 0 ; si c'est le cas, elle lève une IllegalArgumentException.

Exemple

public void checkNumber(int num) {
  if (num < 0) {
    throw new IllegalArgumentException("Number must be positive");
  }
}

Mot-clé throws

throwsLe mot-clé est utilisé dans la déclaration de méthode pour spécifier les exceptions que la méthode peut lever. Lorsqu'une exception du type spécifié est levée à l'intérieur de la méthode, l'exception est transmise au code qui appelle la méthode, et l'exception est gérée dans ce code.

Par exemple, dans le code suivant, lorsqu'une IOException se produit à l'intérieur de la méthode readFile, l'exception est transmise au code qui appelle la méthode. Dans le code qui appelle la méthode, l'IOException doit être interceptée ou déclarée comme étant gérée.

Exemple

public void readFile(String filePath) throws IOException {
  BufferedReader reader = new BufferedReader(new FileReader(filePath));
  String line = reader.readLine();
  while (line != null) {
    System.out.println(line);
    line = reader.readLine();
  }
  reader.close();
}

Une méthode peut déclarer qu'elle lève plusieurs exceptions, séparées par des virgules.

Par exemple, la méthode suivante déclare qu'elle lève RemoteException et InsufficientFundsException :

import java.io.*; public class className { public void withdraw(double amount) throws RemoteException, InsufficientFundsException { // Implémentation de méthode } //Reste de la définition de classe }

Mot-clé finally

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

Qu'une exception se produise ou non, le code dans le bloc finally sera toujours exécuté.

Dans le bloc finally, vous pouvez exécuter des instructions telles que le nettoyage et d'autres opérations de fin.

Le bloc finally apparaît après les blocs catch, et la syntaxe est la suivante :

try{ //code }catch(type d'exception1nom de variable d'exception1){ //code }catch(type d'exception2nom de la variable d'exception2){ //code }finally{ //code }

Exemple

Code du fichier ExcepTest.java :

public class ExcepTest{ public static void main(String args[]){ int a[] = new int[2]; try{ System.out.println("Accéder à l'élément trois :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception levée :" + e); } finally{ a[0] = 6; System.out.println("Valeur du premier élément : " +a[0]); System.out.println("L'instruction finally est exécutée"); } } }

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

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

Notez ce qui suit :

  • Un catch ne peut pas exister indépendamment d'un try.
  • L'ajout d'un bloc finally après try/catch n'est pas obligatoire.
  • Après un bloc try, il doit y avoir au moins un bloc catch ou un bloc finally.
  • Aucun code ne peut être ajouté entre les blocs try, catch et finally.

try-with-resources

Après JDK 7, Java a introduit une nouvelletry-with-resourcestructure syntaxique, qui vise à gérer automatiquement les ressources, en garantissant que les ressources sont fermées à temps après utilisation, afin d'éviter les fuites de ressources.

try-with-resources est un mécanisme de gestion des exceptions qui ferme automatiquement les ressources déclarées dans un bloc try, sans qu'il soit nécessaire de les fermer explicitement dans un bloc finally.

Dans une instruction try-with-resources, il suffit de déclarer les ressources après le mot-clé try, suivi d'un bloc de code. Que les opérations dans le bloc de code réussissent ou non, les ressources seront automatiquement fermées après l'exécution du bloc try.

try (resource declaration) {
  // 使用的资源
} catch (ExceptionType e1) {
  // 异常块
}

Dans la syntaxe ci-dessus, try est utilisé pour déclarer et instancier des ressources, et catch est utilisé pour gérer les exceptions qui peuvent être levées lors de la fermeture des ressources.

Remarque :L'instruction try-with-resources ferme toutes les ressources qui implémentent l'interface AutoCloseable.

Exemple

import java.io.*;

public class ExampleTest {

    public static void main(String[] args) {
    String line;
        try(BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            while ((line = br.readLine()) != null) {
                System.out.println("Line =>"+line);
            }
        } catch (IOException e) {
            System.out.println("IOException in try block =>" + e.getMessage());
        }
    }
}

La sortie de l'exemple ci-dessus est :

IOException in try block =>test.txt (No such file or directory)

Dans l'exemple ci-dessus, nous instancions un objet BufferedReader pour lire les données du fichier test.txt.

Dans l'instruction try-with-resources, l'objet BufferedReader est déclaré et instancié. Une fois l'exécution terminée, la ressource est fermée automatiquement, que l'instruction try s'exécute normalement ou lève une exception.

Si une exception se produit, vous pouvez utiliser catch pour gérer l'exception.

Voyons maintenant comment ne pas utilisertry-with-resourceset utiliser à la placefinallypour fermer les ressources. Le volume global de code est beaucoup plus important, et il est plus complexe et lourd :

Exemple

import java.io.*;

class ExampleTest {
    public static void main(String[] args) {
        BufferedReader br = null;
        String line;

        try {
            System.out.println("Entrée dans le bloc try");
            br = new BufferedReader(new FileReader("test.txt"));
            while ((line = br.readLine()) != null) {
            System.out.println("Line =>"+line);
            }
        } catch (IOException e) {
            System.out.println("IOException in try block =>" + e.getMessage());
        } finally {
            System.out.println("Entrée dans le bloc finally");
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                System.out.println("IOException dans le bloc finally =>"+e.getMessage());
            }
        }
    }
}

La sortie de l'exemple ci-dessus est :

Entering try block
IOException in try block =>test.txt (No such file or directory)
Entering finally block

Gestion de plusieurs ressources avec try-with-resources

Dans une instruction try-with-resources, plusieurs ressources peuvent être déclarées en utilisant des points-virgules;pour séparer les ressources :

Exemple

import java.io.*;
import java.util.*;
class ExampleTest {
    public static void main(String[] args) throws IOException{
        try (Scanner scanner = new Scanner(new File("testRead.txt"));
            PrintWriter writer = new PrintWriter(new File("testWrite.txt"))) {
            while (scanner.hasNext()) {
                writer.print(scanner.nextLine());
            }
        }
    }
}

L'exemple ci-dessus utilise un objet Scanner pour lire une ligne du fichier testRead.txt et l'écrire dans un nouveau fichier testWrite.txt.

Lors de la déclaration de plusieurs ressources, l'instructiontry-with-resourcesferme ces ressources dans l'ordre inverse. Dans cet exemple, l'objet PrintWriter est fermé en premier, puis l'objet Scanner est fermé.

Pour plus d'informations, consultez :

Déclaration d'exceptions personnalisées

En Java, vous pouvez définir des exceptions personnalisées. Gardez les points suivants à l'esprit lorsque vous écrivez votre propre classe d'exception.

  • Toutes les exceptions doivent être des sous-classes de Throwable.
  • Si vous voulez écrire une classe d'exception vérifiée, vous devez hériter de la classe Exception.
  • Si vous voulez écrire une classe d'exception 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{ }

Une classe d'exception créée uniquement en héritant 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 de Exception.

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

Exemple

L'exemple suivant est une simulation d'un compte bancaire. Il identifie le compte par le numéro de carte bancaire et prend en charge les opérations de dépôt et de retrait.

Code du fichier InsufficientFundsException.java :

//Nom du fichier : InsufficientFundsException.java import java.io.*; //Classe d'exception personnalisée, héritant de la classe Exception public class InsufficientFundsException extends Exception { //Le montant ici est utilisé pour stocker le montant qui manque lorsqu'une exception se produit (lorsque le montant du retrait dépasse le solde). private double amount; public InsufficientFundsException(double amount) { this.amount = amount; } public double getAmount() { return amount; } }

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

La classe CheckingAccount ci-dessous contient une méthode withdraw() qui lève une InsufficientFundsException.

Code du fichier CheckingAccount.java :

//Nom du fichier : CheckingAccount.java import java.io.*; //Cette classe simule un compte bancaire public class CheckingAccount { //balance est le solde du compte, number est le numéro de carte private double balance; private int number; public CheckingAccount(int number) { this.number = number; } //Méthode : déposer de l'argent public void deposit(double amount) { balance += amount; } //Méthode : retirer de l'argent public void withdraw(double amount) throws InsufficientFundsException { if(amount <= balance) { balance -= amount; } else { double needs = amount - balance; throw new InsufficientFundsException(needs); } } //Méthode : retourner le solde public double getBalance() { return balance; } //Méthode : retourner le numéro de carte public int getNumber() { return nombre; } }

Le programme BankDemo ci-dessous montre comment appeler les méthodes deposit() et withdraw() de la classe CheckingAccount.

Code du fichier BankDemo.java :

//Nom du fichier : BankDemo.java public class BankDemo { public static void main(String [] args) { CheckingAccount c = new CheckingAccount(101); System.out.println("Dépôt de $500..."); c.deposit(500.00); try { System.out.println("\nRetrait de $100..."); c.withdraw(100.00); System.out.println("\nRetrait de $600..."); c.withdraw(600.00); }catch(InsufficientFundsException e) { System.out.println("Désolé, mais il vous manque $" + e.getAmount()); e.printStackTrace(); } } }

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

Depositing $500...

Withdrawing $100...

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

Exceptions générales

Java définit deux types d'exceptions et d'erreurs.

  • JVM(Javamachine virtuelle)Exceptions :Exceptions ou erreurs lancées par la JVM. Par exemple : classe NullPointerException, classe ArrayIndexOutOfBoundsException, classe ClassCastException.
  • Exceptions au niveau du programme :Exceptions lancées par des programmes ou des programmes d'API. Par exemple : classe IllegalArgumentException, classe IllegalStateException.

Bonnes pratiques de gestion des exceptions

  • Interceptez les exceptions aux emplacements appropriés et gérez-les correctement afin de garantir la stabilité et la fiabilité du programme.
  • Évitez de capturer excessivement les exceptions ; essayez de capturer précisément des types spécifiques d'exceptions.
  • Utilisez des blocs finally pour libérer des ressources, comme la fermeture de fichiers ou de connexions à des bases de données, afin de garantir que les ressources sont correctement libérées.
  • Donnez la priorité à la gestion des exceptions vérifiées et évitez de convertir des exceptions vérifiées en exceptions non vérifiées.

La gestion des exceptions est une partie importante de l'écriture d'applications Java robustes. Une gestion correcte des exceptions peut améliorer la maintenabilité et la fiabilité du programme.

Autres extensions