Le langage de programmation Java fournit un mécanisme permettant de gérer les exceptions lancées par le programme.

Lorsqu'une exception se produit, le traitement normal du programme s'interrompt et l'environnement d'exécution tente de trouver le gestionnaire d'exception chargé de gérer le type d'erreur en cours.

Le gestionnaire d'exception peut tenter de récupérer l'erreur si cela est possible, sinon il essayera de provoquer une sortie correcte du programme.

try{
  // Instructions...
}
catch (type_exception1 nom){
  // Instructions de traitement d'exception
}
...
catch (type_exceptionN nom){
  // Instructions de traitement d'exception
}
finally{
  // Instructions de fin...
}

public class RacineCarre {
  static public void main(String[] args) {
    int dividende = 9;
    int diviseur = 0;

    try {
      System.out.println("La division de " + dividende "/" + diviseur 
                          + " est égale à " + dividende/diviseur);
    }
    catch(ArithmeticException e) {
      System.out.println("Une exception s'est produite !rn" 
                                     + e.getMessage());
      System.out.println("rnAffichage de la pile :rn");
      e.printStackTrace();
    }
    finally {
      System.out.println("Je vous remercie d'avoir essayé !")); 
    }
  }
}

L'instruction try contient un bloc d'instructions à l'intérieur duquel une exception pourrait se produire.

L'instruction catch doit être associée à try et contient un bloc d'instructions susceptible de gérer un type d'exception particulier.

L'instruction finally facultative, doit être associée à try et placée après catch. Elle contient un bloc d'instructions qui est exécuté dans tous les cas de figure.

Il est possible d'utiliser plusieurs instructions catch afin de capturer des exceptions de types différents.

Cette succession de blocs catch doit correspondre à un ordre précis afin de correspondre à la hiérarchie inverse des classes d'exception.

Ainsi, les types d'exception risquant de se produire dans les sous-classes inférieures d'une hiérarchie devront être traités en premier, suivi de ceux des classes supérieures.

Si une exception se produit dans le bloc try, alors la machine virtuelle Java recherchera le bloc catch le plus approprié à l'exception en cours.

try {
  // Bloc d'instructions...
}
catch (FileNotFoundException e) {
  // Gestion des exceptions de fichier non trouvé
}
catch (IOException e) {
  // Gestion des exceptions d'entrée/sortie
}
catch (Exception e) {
  // Gestion des exceptions
}

Par exemple, si une exception du type FileNotFoundException se produit dans le bloc try, le bloc catch (FileNotFoundException e) intercepterait et gérerait l'exception en cours.
Si une exception du type EOFException se produit, alors ce serait au tour du bloc catch (IOException e) de traiter cette exception puisqu'elle est provient d'une sous-classe de IOException.
Enfin, si une exception du type BadLocationException se produit, alors le dernier bloc catch prendrait en compte cette exception car celle-ci descend de la classe Exception.

Les instructions try... catch peuvent être imbriquées les unes dans les autres.

try {
  // Bloc try 1
  ...
  try {
    // Bloc try 2
    ...
  }
  catch (TypeException e) {
    ...
  }
  ...
}
catch (TypeException e) {
  ...
}

Dans ce cas, si une exception est lancée dans le second bloc try terminant de fait son exécution, son bloc catch est vérifié pour une éventuelle interception. S'il n'est pas en mesure de gérer l'exception, alors cette dernière est propagée dans le premier bloc try qui ensuite transmet l'exception à son bloc catch.

L'omission du bloc catch est permise dans la mesure où le bloc try est suivi d'un bloc finally, mais les exceptions doivent être déclarées à partir de la méthode en cours.

Plusieurs méthodes des classes d'exceptions permettent de retourner des informations relatives à l'erreur en cours. Il s'agît de :

• getMessage() : retourne une chaîne de caractères représentant le message relatif à l'exception,
• toString() : retourne une courte description de l'exception. Si cette dernière a été créée avec un message d'erreur, le résultat serait la concaténation du nom de la classe, d'un deux-points suivi d'un espace et d'une chaîne de caractères provenant de getMessage(),
• printStackTrace() : retourne la trace de la pile au flux de sortie standard qui est la valeur du champ System.err. La première ligne de sortie contient le résultat produit par toString(). Les autres lignes représente les données au préalable enrgistrées par la méthode fillInStackTrace().
• fillInStackTrace() : Fills in the execution stack trace. This method enregistre les informations de l'exception courant à propos de l'état courant des piles pour le thread courant.

import java.io.*;

public class Ecrire {
  public static void main(String[] args) {
    try {
      FileWriter sortie = new FileWriter("titre");
      sortie.write("Un texte...");
      sortie.flush();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
  }
}