Gestion de Plusieurs Exceptions

Comme mentionné dans le chapitre précédent, nous pouvons avoir plusieurs exceptions, et pour chacune de ces exceptions, nous pouvons avoir un bloc catch séparé.

Blocs `catch` multiples

Jetons un coup d'œil à un exemple de code qui analyse une String en un int et ensuite effectue une division. Dans ce cas, il peut y avoir deux exceptions :

ArithmeticException si nous tentons une division par zéro ;
NumberFormatException s'il est impossible de convertir la String en int.

La méthode est très simple mais génère suffisamment d'exceptions.

Utilisons cette méthode dans la classe principale et gérons les deux exceptions en utilisant une structure try-catch :

main


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10";
            int divisor = 0;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException caught");
        } catch (NumberFormatException e) {
            System.out.println("NumberFormatException caught");
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Comme vous pouvez le voir, nous gérons plusieurs exceptions, l'une après l'autre, en utilisant deux blocs catch. Si nous attrapons la première exception, dans notre cas, ArithmeticException, nous entrons dans le premier bloc catch et affichons les informations nécessaires à l'écran.

Si nous attrapons la deuxième erreur, qui est NumberFormatException dans ce cas, nous entrons dans le bloc catch suivant, où nous affichons les informations requises à l'écran.

Nous donnons également à chacune des erreurs un alias, 'e', ce qui nous permet d'accéder à l'objet et de comprendre ce qui s'est mal passé.

Cela se fait en utilisant e.getMessage(). Dans le code, cela ressemblera à ceci :

main


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10";
            int divisor = 0;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException caught: " + e.getMessage());
        } catch (NumberFormatException e) {
            System.out.println("NumberFormatException caught: " + e.getMessage());
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Combinaison de plusieurs blocs `catch`

Vous pouvez remarquer que nous effectuons la même opération dans les deux blocs catch, ce qui suggère l'idée que nous pourrions les combiner. Java nous permet de le faire en capturant les deux objets d'exception dans un seul bloc catch.

Par exemple :

main


              123456789101112131415161718192021222324
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10d";
            int divisor = 2;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (ArithmeticException | NumberFormatException e) {
            System.out.println(e.getClass().getSimpleName() + " caught: " + e.getMessage());
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Nous avons listé plusieurs exceptions possibles que nous pouvons capturer en utilisant le OU bit à bit (|). De cette façon, dans un seul bloc catch, nous capturons deux exceptions possibles simultanément et affichons un message commun pour elles.

Nous pouvons légèrement raccourcir ce bloc catch en utilisant l'objet de la classe d'exception parente : RuntimeException.

Implémentons cela dans le code ci-dessous :

main


              123456789101112131415161718192021222324
            
package com.example;

public class Main  {

    public static void main(String[] args) {
        try {
            // Call the method that might throw multiple exceptions
            String input = "10";
            int divisor = 0;
            double result = divideAndConvert(input, divisor);
            System.out.println("Result: " + result);
        } catch (RuntimeException e) {
            System.out.println(e.getClass().getSimpleName() + " caught: " + e.getMessage());
        }
    }

    public static double divideAndConvert(String numberStr, int divisor) {
        int number = Integer.parseInt(numberStr); // Can throw NumberFormatException
        if (divisor == 0) {
            throw new ArithmeticException("You can't divide by zero!");
        }
        return (double) number / divisor; // Can throw ArithmeticException
    }
}

Nous pouvons conclure que les exceptions ont également leur propre hiérarchie d'héritage, et nous pouvons substituer une classe enfant par une classe parente, ainsi qu'utiliser l'inversion de dépendance.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 3

Bibliothèque Java JUnit. Types de Tests

Gestion de Plusieurs Exceptions

Blocs `catch` multiples

Combinaison de plusieurs blocs `catch`

1. Quelles exceptions la méthode `divideAndConvert` peut-elle potentiellement lancer ?

2. Dans l'exemple fourni, qu'est-ce qui provoque une `NumberFormatException`?

3. Quel est le but de combiner plusieurs blocs catch?

4. Comment pouvez-vous attraper plusieurs exceptions dans un seul bloc catch?

5. Si vous attrapez `RuntimeException`, quels types d'exceptions gérez-vous ?

Bibliothèque Java JUnit. Types de Tests

Gestion de Plusieurs Exceptions

Blocs `catch` multiples

Combinaison de plusieurs blocs `catch`

1. Quelles exceptions la méthode divideAndConvert peut-elle potentiellement lancer ?

2. Dans l'exemple fourni, qu'est-ce qui provoque une NumberFormatException?

3. Quel est le but de combiner plusieurs blocs catch?

4. Comment pouvez-vous attraper plusieurs exceptions dans un seul bloc catch?

5. Si vous attrapez RuntimeException, quels types d'exceptions gérez-vous ?

1. Quelles exceptions la méthode `divideAndConvert` peut-elle potentiellement lancer ?

2. Dans l'exemple fourni, qu'est-ce qui provoque une `NumberFormatException`?

5. Si vous attrapez `RuntimeException`, quels types d'exceptions gérez-vous ?