Gestion des exceptions en Java (Try / Catch / Throws ..)

Une exception en Java est un événement indésirable qui se produit et perturbe le déroulement normal du programme. Elles sont récupérables.
Un développeur peut gérer de telles conditions et prendre les mesures correctives nécessaires. Parmi ces exceptions, citons NullPointerException, SQLException, ClassNotFoundException et RuntimeException.
Par exemple, un nombre divisé par zéro est un type de RuntimeException.

Exemple avec ce bout de code très poussé :

public class myCode {
   public static void main(String[] args){
   
      int nb1 = 10;
      int nb2 = 0;
      int result = nb1 / nb2;
   }
}

A l’exécution nous avons donc cette erreur :

Output: java.lang.ArithmeticException: at myCode.main(Example.java:5)

C’est un problème qui se produit principalement en raison du manque de ressources du système. Elles sont irrécupérables.
Parmi elles, citons StackOverflowError, VirtualMachineError et OutofMemoryError.
Par exemple, StackOverflowError est une erreur récursive infinie, dans laquelle une fonction s’appelle elle-même tellement de fois que l’espace nécessaire pour stocker les variables et les informations associées à chaque appel est supérieur à ce que peut contenir la pile.

Exemple d’erreur StackOverflowError avec ce bout de code :

public class myCode {

   public static void main(String[] args){
      methodRecursive();
   }
   
   public static void methodRecursive(){
      while(true){
         methodRecursive();
      }
   }
}

Output: Exception in thread "main" java.lang.StackOverflowError
 at ErrorExample.methodRecursive(Main.java:8)
 at ErrorExample.methodRecursive(Main.java:8)
 at ErrorExample.methodRecursive(Main.java:8)
 at ErrorExample.methodRecursive(Main.java:8)

BAAAAM !!!!!!

Gestion des exceptions : Il s’agit du mécanisme permettant de gérer les erreurs d’exécution de manière à ce que l’exécution normale de l’application puisse être maintenue.
Une exception perturbe normalement le déroulement normal du programme, c’est pourquoi nous utilisons la gestion des exceptions.

Un petit schéma de la hiérarchie des exceptions en Java :

Il existe deux types d’exceptions en Java :

1. Les exceptions vérifiées (Checked Exception) : Ces exceptions sont vérifiées au moment de la compilation pour voir si le programmeur les a traitées ou non. Si ces exceptions ne sont pas traitées dans le programme, vous obtiendrez une erreur de compilation. Par exemple, SQLException, IOException, ClassNotFoundException, …
2. Les exceptions non-vérifiées (Unchecked Exception) : Ces exceptions sont vérifiées au moment de l’exécution, il incombe donc au développeur de les gérer. Par exemple, ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, …

Try Block : C’est un bloc qui se compose d’instructions où les exceptions sont susceptibles de se produire. Un bloc try est toujours suivi d’un bloc catch où ces exceptions sont traitées.
Un bloc try doit être suivi d’un bloc catch ou d’un bloc finally ou des deux.

try {
   // Déclarations susceptibles de provoquer une exception
}

Catch Block : Il s’agit d’un bloc permettant de gérer les exceptions qui se produisent dans le bloc try.
Lorsqu’une exception se produit dans le bloc try, le bloc catch qui gère cette exception particulière s’exécute.

try {
     // Déclarations susceptibles de provoquer une exception
} catch (Exception(type) e(object))‏ {
     // Code de gestion des erreurs
}

Voyons maintenant notre code de tout à l’heure concernant la division par 0 :

class codeWithHandling {
      public static void main(String args[]){ 
      
          int nb1 = 10;
          int nb2 = 0;
          
          try {
             System.out.println("Déclaration 1");
             System.out.println("Déclaration 2");
             int result = nb1 / nb2;
             System.out.println("Déclaration 4");
          } catch (ArithmeticException e){
              System.out.println("Diviser un nombre par zéro ?" + e.getMessage());
           }
      }
  }

Déclaration 1
Déclaration 2
Diviser un nombre par zéro ?/ by zero
Process finished with exit code 0

Dans l’exemple ci-dessus, lorsqu’un nombre est divisé par zéro, une ArithmeticException est survenue, capturée par le bloc catch.
Le bloc de code situé après l’instruction où l’exception s’est produite ne sera jamais exécuté.

Magnifique n’est ce pas ?

Finally Block : Il s’agit d’un bloc qui sera définitivement exécuté, qu’une exception se soit produite ou non :

try {
    // Déclarations susceptibles de provoquer une exception
} catch(Exception(type) object) {
   // Traitement des exceptions
} finally {
   // Déclarations à exécuter
}

class Solution {
    public static void main(String args[]) {
    
        int nb1 = 10;
        int nb2 = 0;
        
        try {
            int result = nb1 / nb2;
        } catch (ArithmeticException e) {
            System.out.println("Nombre divisé par zéro ?" + e.getMessage());
        } finally {
            System.out.println("Finally Block est exécuté");
        }
    }
}

Nombre divisé par zéro ?/ by zero
Finally Block est exécuté
Process finished with exit code 0

Throw : C’est un mot-clé qui est utilisé pour lancer notre propre exception personnalisée.
Supposons que vous vouliez créer un programme qui permette aux personnes de voter aux élections si elles ont 18 ans ou plus. Nous pouvons alors utiliser le mot-clé throw pour lancer notre propre exception personnalisée.
Si l’âge d’une personne est inférieur à 18 ans, le programme affichera “Vous n’êtes pas autorisé à voter”.

class Solution {

    public static void main(String args[]) {
        int agePerson1 = 18;
        int agePerson2 = 3;
        checkEligibility(agePerson1);
        checkEligibility(agePerson2);
    }
    
    static void checkEligibility(int age) 
        if (age < 18) {
            throw new ArithmeticException("Vous n'êtes pas autorisé à voter");
        } else {
            System.out.println("Vous êtes autorisé à voter");
        }
    }
}

Vous êtes autorisé à voter
Exception in thread "main" java.lang.ArithmeticException: Vous n'êtes pas autorisé à voter
	at Solution.checkEligibility(Solution.java:13)
	at Solution.main(Solution.java:8)
Process finished with exit code 1

Throws : principalement utilisé pour déclarer une exception. Il indique au développeur qu’il est possible qu’une exception se produise et qu’il est préférable de fournir le code de gestion des exceptions pour maintenir le bon déroulement du programme.

public void maMethode () throws ArithmeticException {
        // Déclarations susceptibles d'entraîner une exception
        }
        
public static void main(String args[]){

        try {
            maMethode();
        } catch(ArithmeticException e){
        // Déclarations de traitement des exceptions
        } catch(NullPointerException e){
        // Déclarations de traitement des exceptions
     }
}

Exemple :

class Solution {
    void method() throws IOException {
        throw new IOException("Erreur");
    }
}

class TestThrow {
    public static void main(String args[]) throws IOException {
        Solution m = new Solution();
        m.method();
        System.out.println("Bon déroulement");
    }
}

Exception in thread "main" java.io.IOException: Erreur
	at Solution.method(Solution.java:5)
	at TestThrow.main(Solution.java:12)
Process finished with exit code 1

Voila pour une introduction à la gestion des exceptions en Java.