Exceptions en Java (exception Java)

Dans la vie de tous les jours, il arrive parfois que des situations imprévues surviennent. Par exemple, vous vous levez le matin pour travailler et cherchez un chargeur pour votre téléphone, mais il n’y en a pas. Vous allez aux toilettes pour vous laver le visage - l'eau a été coupée. Je suis monté dans la voiture et elle ne démarrait pas. Mais une personne est capable de faire face assez facilement à de telles situations imprévues. Nous essaierons de comprendre comment les programmes Java les gèrent dans cet article.

Quelles sont les exceptions Java

Dans le monde de la programmation, l’apparition d’erreurs et de situations inattendues lors de l’exécution d’un programme est appelée une exception. Dans un programme, des exceptions peuvent survenir en raison d'actions incorrectes de l'utilisateur, de l'absence d'une ressource nécessaire sur le disque ou d'une perte de connexion au serveur via le réseau. Des exceptions lors de l'exécution du programme peuvent également être provoquées par des erreurs de programmation ou une utilisation incorrecte de l'API. Contrairement à notre monde, le programme doit clairement savoir quoi faire dans une telle situation. Java fournit un mécanisme d'exception à cet effet.

En bref sur les mots-clés essayer, attraper, enfin, lancer

La gestion des exceptions en Java est basée sur l'utilisation des mots-clés suivants dans le programme :

• try - définit un bloc de code dans lequel une exception peut se produire ;
• catch – définit le bloc de code dans lequel l'exception est gérée ;
• enfin – définit un bloc de code facultatif, mais s'il est présent, il est quand même exécuté, quels que soient les résultats du bloc try.

Ces mots-clés sont utilisés pour créer des constructions de traitement spéciales dans le code du programme : try{}catch, try{}catch{}finally, try{}finally{}.

• throw – utilisé pour déclencher une exception ;
• throws – utilisé dans les signatures de méthode pour avertir qu’une méthode peut lever une exception.

Un exemple d'utilisation de mots-clés dans un programme Java :

//method reads a string from the keyboard

public String input() throws MyException {//warn with throws,
// that the method can throw MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// in the try block we enclose the code in which an exception can occur, in this
// if the compiler tells us that the readLine() method of the class
// BufferedReader may throw an I/O exception
    try {
        s = reader.readLine();
// in the catch block we enclose the code for handling the IOException exception
    } catch (IOException e) {
        System.out.println(e.getMessage());
// close the read stream in the finally block
    } finally {
// when closing the stream, an exception is also possible, for example, if it was not opened, so we “wrap” the code in a try block
        try {
            reader.close();
// write exception handling when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// we decided that an empty string could disrupt the work of our program in the future, for example, on the result of this method, we need to call the substring(1,2) method, so we are forced to interrupt the program execution with the generation of our exception type MyException using throw
        throw new MyException("String can not be empty!");
    }
    return s;
}

Pourquoi avons-nous besoin d’un mécanisme d’exception ?

Regardons un exemple du monde réel. Imaginez qu'il y ait un tronçon d'autoroute avec un pont de secours avec une capacité de charge limitée. Si un véhicule dont la masse dépasse la capacité de charge du pont le traverse, celui-ci peut s'effondrer et la situation pour le conducteur peut devenir, pour le moins, exceptionnelle. Pour éviter que cela ne se produise, le service routier installe à l'avance des panneaux d'avertissement sur la route. Le conducteur de la voiture, en regardant le panneau d'avertissement, comparera le poids de sa voiture avec celui autorisé pour circuler sur le pont. Si cela le dépasse, il fera un détour. Grâce aux actions du service routier, les chauffeurs routiers, d'une part, ont eu la possibilité de modifier leur itinéraire à l'avance, d'autre part, ils ont été avertis du danger sur l'itinéraire principal et, enfin, de l'impossibilité d'utiliser le pont sous certaines conditions. La possibilité d'empêcher et de résoudre une exception dans un programme afin qu'elle puisse continuer est l'une des raisons pour lesquelles les exceptions sont utilisées en Java. Le mécanisme d'exception vous permet également de protéger le code que vous écrivez (interface de programmation) contre toute utilisation abusive par l'utilisateur en validant (vérifiant) les données entrantes. Maintenant, soyons la police de la circulation pendant une seconde. Tout d’abord, vous devez connaître les endroits où les automobilistes peuvent avoir des ennuis. Deuxièmement, vous devez préparer et installer des panneaux d’avertissement. Enfin, il faut prévoir des itinéraires de détour en cas de danger sur l'itinéraire principal. En Java, le mécanisme d'exception fonctionne de la même manière. Au stade du développement du programme, nous « protégeons » les sections de code dangereuses des exceptions à l'aide du bloc try{}, fournissons des chemins de « sauvegarde » à l'aide du bloc catch{} et dans le bloc enfin{}, nous écrivons du code qui est exécuté dans le programme pour n’importe quel résultat. Dans les cas où nous ne pouvons pas prévoir un « itinéraire de secours » ou voulons délibérément laisser le choix à l'usager, nous devons au moins l'avertir du danger. Pourquoi? Imaginez l'indignation d'un automobiliste qui atteint un pont de secours qu'il est impossible de traverser sans rencontrer un seul panneau d'avertissement en cours de route ! En programmation, lors de l'écriture de nos classes et méthodes, nous ne pouvons pas toujours prévoir le contexte de leur utilisation par d'autres développeurs dans leurs programmes, nous ne pouvons donc pas prévoir le chemin correct à 100 % pour résoudre la situation d'exception. Dans le même temps, il est de bonne pratique d’avertir les utilisateurs de notre code de la possibilité d’une exception. Le mécanisme d'exception de Java nous permet de le faire en utilisant des lancers, en déclarant essentiellement le comportement général de notre méthode pour lever une exception, laissant ainsi à l'utilisateur de la méthode le soin d'écrire du code pour gérer l'exception en Java.

Avertissement de "problème"

Lorsque vous ne prévoyez pas de gérer une exception dans votre méthode, mais que vous souhaitez avertir les utilisateurs de la méthode des situations d'exception possibles, utilisez le mot-clé throws. Ce mot-clé dans une signature de méthode signifie que sous certaines conditions, la méthode peut lever une exception. Cet avertissement fait partie de l'interface de la méthode et donne à l'utilisateur le droit de personnaliser l'implémentation du gestionnaire d'exceptions. Après les lancements, nous indiquons le type d'exception levée. Ce sont généralement des descendants de la classe Java Exception . Puisque Java est un langage orienté objet, toutes les exceptions en Java sont des objets.

Hiérarchie des exceptions Java

Lorsqu'une erreur se produit lors de l'exécution du programme, le runtime JVM crée un objet du type requis à partir de la hiérarchie des exceptions Java - l'ensemble des exceptions possibles héritées d'un « ancêtre » commun - la classe Throwable. Les situations exceptionnelles qui surviennent dans un programme peuvent être divisées en deux groupes :

1. Situations dans lesquelles le rétablissement du fonctionnement normal du programme est impossible
2. La récupération est possible.

Le premier groupe comprend les situations dans lesquelles des exceptions héritées de la classe Error se produisent . Il s'agit d'erreurs qui se produisent lors de l'exécution du programme à la suite d'une défaillance de la JVM, d'un débordement de mémoire ou d'un crash du système. Ils indiquent généralement des problèmes graves qui ne peuvent pas être résolus à l'aide d'un logiciel. Ce type d'exception en Java est classé comme non vérifié au stade de la compilation. Ce groupe comprend également RuntimeException - exceptions, héritiers de la classe Exception , générées par la JVM lors de l'exécution du programme. Ils sont souvent causés par des erreurs de programmation. Ces exceptions sont également décochées au moment de la compilation, il n'est donc pas nécessaire d'écrire du code pour les gérer. Le deuxième groupe comprend les situations exceptionnelles prévues au stade de l'écriture du programme et pour lesquelles du code de traitement doit être écrit. Ces exceptions sont vérifiées. L'essentiel du travail d'un développeur Java lorsqu'il traite des exceptions consiste à gérer de telles situations.

Créer une exception

Pendant l'exécution du programme, une exception est levée par la JVM ou manuellement à l'aide de l' instruction throw . Cela crée un objet d'exception en mémoire et interrompt l'exécution du code du programme principal pendant que le gestionnaire d'exceptions JVM tente de trouver un moyen de gérer l'exception.

Gestion des exceptions

La création de blocs de code pour lesquels nous fournissons la gestion des exceptions en Java est effectuée dans le programme à l'aide des constructions try{}catch, try{}catch{}finally, try{}finally{}. Lorsqu'une exception est déclenchée dans un bloc try, le gestionnaire d'exceptions est recherché dans le bloc catch suivant. Si le catch contient un gestionnaire pour ce type d’exception, le contrôle lui est transmis. Sinon, la JVM recherche un gestionnaire pour ce type d'exception dans la chaîne d'appels de méthode jusqu'à ce qu'une capture appropriée soit trouvée. Une fois le bloc catch exécuté, le contrôle est passé à un bloc final facultatif . Si un bloc catch approprié n'est pas trouvé, la JVM arrête l'exécution du programme et affiche une pile d'appels de méthode - stack trace , après avoir préalablement exécuté le code du bloc final, le cas échéant. Exemple de gestion des exceptions :

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside method print: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s:list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception was processed. Program continues");
            }
            finally {
                System.out.println("Inside bloсk finally");
            }
            System.out.println("Go program....");
            System.out.println("-----------------");
        }

    }
    }

Les résultats de la méthode principale :

Inside method print: first step
Inside bloсk finally
Go program....
-----------------
Exception: s is null!
Exception was processed. Program continues
Inside bloсk finally
Go program....
-----------------
Inside method print: second step
Inside bloсk finally
Go program....
-----------------

Le bloc finallyest généralement utilisé pour fermer les flux ouverts dans le bloc try ou pour libérer des ressources. Cependant, lors de l'écriture d'un programme, il n'est pas toujours possible de suivre la fermeture de toutes les ressources. Pour nous faciliter la vie, les développeurs Java nous ont proposé une construction try-with-resourcesqui ferme automatiquement les ressources ouvertes dans un bloc try. Notre premier exemple peut être réécrit ainsi try-with-resources:

public String input() throws MyException {
    String s = null;
    try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")){
        throw new MyException ("String can not be empty!");
    }
    return s;
}

Grâce aux capacités de Java, à partir de la version 7, nous pouvons également combiner la capture de différents types d'exceptions dans un seul bloc, rendant le code plus compact et plus lisible. Par exemple:

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("String can not be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

Résultats

L'utilisation d'exceptions en Java nous permet d'augmenter la tolérance aux pannes du programme grâce à l'utilisation de chemins de « sauvegarde », de séparer la logique du code principal du code de gestion des exceptions grâce à l'utilisation de blocs catch, et nous donne également la possibilité de déléguer gestion des exceptions à l'utilisateur de notre code à l'aide de lancers.