L'utilisation de blocs de code try and catch pour la gestion des exceptions en Java

Utilisation de Java try and catch
Bien que les gestionnaires d'exceptions par défaut fournis par le système d'exécution Java soient utiles pour le débogage, vous souhaitez généralement gérer les exceptions vous-même. Cela présente deux avantages. Premièrement, cela vous permet de corriger les erreurs. Deuxièmement, cela empêche le programme de se terminer automatiquement. La plupart des utilisateurs sont ennuyés (c'est le moins qu'on puisse dire) par l'impression d'une trace de pile à la fin du programme et à chaque fois qu'une erreur se produit. Heureusement, cela est facilement évitable.

Pour éviter et gérer une erreur d'exécution, placez simplement le code que vous souhaitez surveiller dans un bloc try. Immédiatement après le bloc try, incluez une clause catch qui spécifie le type d'erreur que vous souhaitez intercepter. Réaliser cette tâche est simple. Le programme suivant contient un bloc try et une clause catch qui gère les exceptions ArithmeticException provoquées par la division par zéro.

class Exc2 {
  public static void main(String args[]) {
    int d, a;
    try { // monitor a block of code.
      d = 0;
      a = 42 / d;
      System.out.println("This will not be printed.");
    } catch (ArithmeticException e) { // catch divide-by-zero error
      System.out.println("Division by zero.");
    }
    System.out.println("After catch statement.");
  }
}

Le résultat du programme est le suivant :

Division by zero.
After catch statement.

Notez que l'appel à println() dans le bloc try n'est jamais exécuté. Une fois qu'une exception est levée, le contrôle du programme est transféré du bloc try au bloc catch. L'exécution ne "revient" jamais du bloc catch au bloc try. Par conséquent, "Ceci ne sera pas imprimé."

ne sera pas affiché. Une fois l'instruction catch exécutée, le contrôle du programme continue à partir de la ligne située sous l'ensemble du mécanisme try/catch.

Un try et son instruction catch forment une unité. La portée de la clause catch est limitée aux instructions définies avant l'instruction try. Une instruction catch ne peut pas intercepter une exception déclenchée par une autre instruction try (sauf dans le cas d'instructions try imbriquées).

Les déclarations d'instructions protégées par try doivent être entre accolades (c'est-à-dire qu'elles doivent être dans un bloc). Vous ne pouvez pas utiliser try seul.

Le but de la construction d'une clause catch est de résoudre les exceptions et de continuer à s'exécuter comme si l'erreur ne s'était pas produite. Par exemple, dans le programme suivant, chaque itération de la boucle for génère deux entiers aléatoires. Ces deux nombres entiers sont divisés l'un par l'autre et le résultat est utilisé pour diviser 12345. Le résultat final est stocké dans un. Si une opération de division entraîne une erreur de division par zéro, elle est interceptée, la valeur de a est mise à zéro et le programme continue.

// Handle an exception and move on.
import java.util.Random;
 
class HandleError {
  public static void main(String args[]) {
    int a=0, b=0, c=0;
    Random r = new Random();
 
    for(int i=0; i<32000; i++) {
      try {
        b = r.nextInt();
        c = r.nextInt();
        a = 12345 / (b/c);
      } catch (ArithmeticException e) {
        System.out.println("Division by zero.");
        a = 0; // set a to zero and continue
      }
      System.out.println("a: " + a);
    }
  }
}

Afficher une description de l'exception

Throwable surcharge la méthode toString() (définie par Object), elle renvoie donc une chaîne contenant la description de l'exception. Vous pouvez afficher une description d'une exception en lui passant un paramètre dans println(). Par exemple, le bloc catch du programme précédent pourrait être réécrit comme

catch (ArithmeticException e) {
  System.out.println("Exception: " + e);
  a = 0; // set a to zero and continue
}

Lorsque cette version est remplacée par la version du programme d'origine et que le programme est exécuté sous l'interpréteur javaJDK standard, chaque division. L'erreur -by-zero affiche le message suivant :

Exception: java.lang.ArithmeticException: / by zero

Bien qu'elle n'ait aucune valeur particulière dans le contexte, la possibilité d'afficher une description d'exception peut être utile dans d'autres situations - en particulier lorsque vous expérimentez et déboguez. exceptions.

Utilisation de plusieurs instructions catch Java
Dans certains cas, plusieurs exceptions peuvent être provoquées par un seul segment de code. Pour gérer cette situation, vous pouvez définir deux ou plusieurs clauses catch, chacune interceptant un type d'exception. Lorsqu'une exception est levée, chaque clause catch est vérifiée tour à tour et la première correspondant au type d'exception est exécutée. Lorsqu'une instruction catch est exécutée, les autres clauses sont contournées et l'exécution continue à partir du code après le bloc try/catch. L'exemple suivant conçoit deux types d'exceptions différents :

// Demonstrate multiple catch statements.
class MultiCatch {
  public static void main(String args[]) {
    try {
      int a = args.length;
      System.out.println("a = " + a);
      int b = 42 / a;
      int c[] = { 1 };
      c[42] = 99;
    } catch(ArithmeticException e) {
      System.out.println("Divide by 0: " + e);
    } catch(ArrayIndexOutOfBoundsException e) {
      System.out.println("Array index oob: " + e);
    }
    System.out.println("After try/catch blocks.");
  }
}

Le programme exécuté dans la condition de démarrage sans paramètres de ligne de commande entraîne une exception de division par zéro car a vaut 0. Si vous fournissez un argument de ligne de commande, il survivra et définira a sur une valeur supérieure à zéro. Mais cela provoquera une exception ArrayIndexOutOf BoundsException car la longueur du tableau d'entiers c est 1 et le programme tente d'attribuer une valeur à c[42].

Voici le résultat de l'exécution du programme dans deux situations différentes :

C:\>java MultiCatch
a = 0
Divide by 0: java.lang.ArithmeticException: / by zero After try/catch blocks.
C:\>java MultiCatch TestArg
a = 1
Array index oob: java.lang.ArrayIndexOutOfBoundsException After try/catch blocks.

Lorsque vous utilisez plusieurs instructions catch, n'oubliez pas que les sous-classes d'exception doivent être utilisées avant chacune de leurs classes parentes Very. important. En effet, l'utilisation de l'instruction catch de la classe parent interceptera les exceptions de ce type et toutes ses sous-classes. De cette façon, si la classe enfant est derrière la classe parent, la classe enfant n’arrivera jamais. De plus, le code inaccessible en Java est un bug. Par exemple, considérons le programme suivant :

/* This program contains an error.
A subclass must come before its superclass in a series of catch statements. If not,unreachable code will be created and acompile-time error will result.
*/
class SuperSubCatch {
  public static void main(String args[]) {
    try {
      int a = 0;
      int b = 42 / a;
    } catch(Exception e) {
      System.out.println("Generic Exception catch.");
    }
    /* This catch is never reached because
    ArithmeticException is a subclass of Exception. */
    catch(ArithmeticException e) { // ERROR - unreachable
      System.out.println("This is never reached.");
    }
  }
}

Si vous essayez de compiler ce programme, vous recevrez un message d'erreur indiquant que la deuxième instruction catch ne sera pas atteinte car l'exception a déjà été capturée. Étant donné que ArithmeticException est une sous-classe d'Exception, la première instruction catch gérera toutes les erreurs orientées Exception, y compris ArithmeticException. Cela signifie que la deuxième instruction catch ne s'exécutera jamais. Pour modifier le programme, inversez l'ordre des deux instructions catch.

Pour plus d'articles liés à l'utilisation des blocs de code try and catch pour la gestion des exceptions en Java, veuillez faire attention au site Web PHP chinois !