Lancer plusieurs exceptions en Java

Ce didacticiel montrera comment lever plusieurs exceptions en Java.

Les exceptions sont les événements indésirables et inattendus qui perturbent le flux normal des instructions pendant l’exécution du programme. La classe racine de toutes les exceptions Java est java.lang.Throwable. Cette classe est héritée par les sous-classes Error et exception.

Pour gérer les exceptions, nous utilisons les blocs try...catch.

Dans le bloc try, nous plaçons le code qui peut soulever une exception. Le bloc try n’est pas utilisé seul. Il doit toujours être suivi soit de catch soit de finally. Le bloc catch est utilisé pour intercepter l’exception. Ce bloc peut être suivi du bloc finally. Le bloc finally est utilisé pour exécuter le code important du programme, qu’il y ait ou non une exception.

En Java, nous devrons peut-être faire face à plusieurs exceptions. Il n’est pas possible de lever de nombreuses exceptions en Java. Nous pouvons spécifier plusieurs exceptions, mais une seule d’entre elles sera levée.

Cependant, nous avons quelques alternatives que nous pouvons utiliser pour simuler le lancement de plusieurs exceptions.

Nous pouvons utiliser des exceptions chaînées pour gérer plusieurs exceptions. De telles exceptions indiquent que l’exception déclenchée est causée par une autre exception.

Par exemple,

public class Main {
  public static void main(String[] args) {
    try {
      NumberFormatException ex = new NumberFormatException("NumberFormatException is thrown");
      ex.initCause(new NullPointerException("NullPointerException is the main cause"));
      throw ex;
    }

    catch (NumberFormatException ex) {
      System.out.println(ex);
      System.out.println(ex.getCause());
    }
  }
}

Production:

java.lang.NumberFormatException: NumberFormatException is raised
java.lang.NullPointerException: NullPointerException is the main cause

Notez l’utilisation des méthodes initCause() et getCause(). La fonction initCause() définit la cause de l’exception comme une autre exception et le getCause() renverra la cause de l’exception, dans notre cas étant NullPointerException.

Nous pouvons également utiliser des exceptions supprimées. Ici, nous attachons les exceptions supprimées à l’exception principale. Il a été ajouté en Java 7.

Pour attacher les exceptions supprimées, nous utilisons la fonction addSuppressed(). Nous utilisons cette fonction avec l’objet d’exception principal.

Par exemple,

import java.io.*;
class Main {
  public static void main(String[] args) throws Exception {
    try {
      Exception suppressed = new NumberFormatException();
      Exception suppressed2 = new NullPointerException();

      final Exception exe = new Exception();

      exe.addSuppressed(suppressed);
      exe.addSuppressed(suppressed2);
      throw exe;

    }

    catch (Throwable e) {
      Throwable[] suppExe = e.getSuppressed();
      System.out.println("Suppressed:");
      for (int i = 0; i < suppExe.length; i++) {
        System.out.println(suppExe[i]);
      }
    }
  }
}

Production:

Suppressed:
java.lang.NumberFormatException
java.lang.NullPointerException

Dans l’exemple ci-dessus, nous avons attaché deux exceptions à l’objet principal et imprimé les exceptions supprimées. Pour obtenir toutes les exceptions supprimées, nous utilisons la fonction getSuppressed().