Java lance une exception

Partout où nous allons, des événements imprévisibles nous attendent. Tremblements de terre, actions irrationnelles des gens, météorites... ou quelque chose de plus simple : une ampoule grille, une carte bancaire se démagnétise, une jauge à essence se brise. Nous ne pouvons pas empêcher les événements imprévisibles, mais nous pouvons au moins nous y préparer partiellement. Autrement dit, nous devons préparer certains mécanismes pour y faire face. Dans le monde de la programmation, en particulier dans le langage Java, les événements qui empêchent un programme de fonctionner normalement sont appelés exceptions, et les mécanismes permettant d'éviter les plantages du programme sont appelés gestion des exceptions. Ainsi, lorsqu'un événement inattendu se produit dans un programme, tel qu'une division par zéro, il doit « lever » une exception. La gestion des exceptions est un aspect important de la programmation Java qui aide les développeurs à gérer les erreurs et les exceptions pouvant survenir lors de l'exécution d'un programme. Dans cet article, nous nous concentrerons sur l'un des concepts fondamentaux de la gestion des exceptions : le mot-clé Java throw et comment l'utiliser pour lever une exception.

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

Une exception est un événement qui se produit lors de l'exécution d'un programme et perturbe le flux normal des instructions du programme. Lorsqu'une exception se produit, l'exécution du programme est interrompue et le message d'erreur s'affiche sur la console. En Java, il existe deux types d’exceptions : cochées et non cochées. Les exceptions vérifiées sont vérifiées au moment de la compilation et le compilateur garantit qu'elles sont interceptées ou déclarées par la méthode appelante. D'un autre côté, les exceptions non contrôlées ne sont pas vérifiées au moment de la compilation et peuvent être interceptées ou laissées non interceptées. Voici un exemple de code dans lequel une erreur peut se produire, mais le compilateur l'ignore.

public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

Voici le résultat du programme : Le programme s'est terminé correctement, mais a produit un résultat incorrect. Dans le premier cas, parce que l'argument de la fonction était négatif et que la factorielle ne fonctionne pas pour les nombres négatifs. Dans le deuxième cas, le résultat était erroné, car le nombre est trop grand pour que sa factorielle soit comptée dans la plage des types longs. Voici un autre exemple. Écrivons un programme dans lequel nous diviserons un nombre par un autre.

public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

Dans cet exemple, une ArithmeticException va être levée car la variable b est nulle. Cependant, cette erreur n'est pas gérée et le programme se termine donc avec un statut incorrect.

Comment lever une exception en Java

En Java, les exceptions sont également des objets, donc une exception est levée tout comme un nouvel objet Exception créé. Une exception est levée dans un programme à l'aide de l'instruction throw. Habituellement, ces deux opérations (création d'objet et levée d'une exception) sont combinées en une seule :

throw new Exception("error…");

Le mot-clé throw en Java est utilisé pour lever une exception à partir d'une méthode ou d'un bloc de code lorsqu'une erreur ou une condition exceptionnelle se produit que le programme ne peut pas gérer au moment de l'exécution. Le flux du programme est redirigé vers le bloc catch le plus proche. Ce bloc peut gérer l'exception.

Exemple d'utilisation du mot clé « throw »

Pour illustrer la fonctionnalité du mot-clé throw en Java, prenons un exemple. Écrivons une méthode pour calculer la factorielle d'un nombre. Si le nombre est négatif, il ne peut pas être calculé, une exception doit donc être levée. De même, si le nombre est trop grand, le résultat factoriel dépassera la taille maximale d'un type long et une autre exception sera levée. Nous avons ici une implémentation de la méthode :

public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

Dans cet exemple, si la valeur de number est négative, le mot-clé throw est utilisé pour lancer une instance de la classe IllegalArgumentException . Si vous exécutez le programme, le message "L'argument n'est pas légal" s'affichera sur la console. L'exécution du programme sera interrompue.

Plus d'erreurs : attraper un exemple d'exception

Rappelons maintenant le deuxième exemple, avec division par zéro, et exécutons-le avec gestion des exceptions.

public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Dans cet exemple, nous avons ajouté une construction try-catch pour gérer l'exception de division par zéro. En bref, try-catch-finally est une construction du langage de programmation Java qui vous permet de gérer les exceptions et d'exécuter du code, qu'une exception se soit produite ou non. try-catch-finally se compose de trois blocs :

• Le bloc try . Un code potentiellement dangereux est exécuté ici. C'est du code qui peut lever une exception. Si une exception se produit dans un bloc try , l'exécution du code dans ce bloc est interrompue et le contrôle est transféré au bloc catch.
• Le bloc catch . Ici, l'exception levée est gérée. Dans le bloc catch , vous pouvez spécifier quelle exception intercepter et quelle logique exécuter lorsqu'elle est interceptée.
Le bloc final . Celui-ci est exécuté indépendamment du fait qu'une exception se soit produite ou non. Le bloc final est utilisé, par exemple, pour libérer des ressources (telles que la fermeture d'un fichier ou d'un socket) qui ont été allouées dans un bloc try. Vous pouvez omettre ce bloc.

La construction try-catch-finally permet un contrôle plus précis de l'exécution du programme en cas de situations exceptionnelles et aide à empêcher l'arrêt inattendu du programme en cas d'erreurs. Maintenant, revenons à notre exemple. Si une division par zéro se produit pendant la méthode de division, une ArithmeticException sera levée, qui est interceptée par le bloc catch. Dans le bloc catch , nous imprimons simplement un message d'erreur sur la console. Si aucune exception ne se produit, le programme poursuivra son exécution.

lance un mot-clé

Le mot-clé throws est utilisé dans la signature de la méthode. Si c'est le cas, cela signifie qu'une exception est levée dans la méthode. Cela peut propager les exceptions dans la pile d'appels et indiquer que les exceptions n'ont pas besoin d'être gérées dans la méthode actuelle. En Java, les « lancements » peuvent également être utilisés pour faire référence à des exceptions personnalisées définies dans un programme. Par exemple, une méthode peut effectuer une division de deux nombres mais lever une IllegalArgumentException si le deuxième argument est zéro :

public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

Cette méthode utilise le mot-clé throws pour indiquer qu'une IllegalArgumentException peut être levée si le deuxième argument est nul. Si une telle exception se produit lors de l’exécution de la méthode, elle sera transmise à la méthode appelante pour traitement. Exemple d'appel de méthode :

public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

Dans cet exemple, la méthode Divide() est appelée avec les arguments 10 et 0, ce qui lèvera une IllegalArgumentException car la division par zéro est impossible. L'exception sera interceptée par un bloc try-catch et un message d'erreur sera affiché. Le programme donnera une valeur de zéro puisque l'exception termine l'exécution de la méthode Divide() .