1. Introduction
En programmation, il arrive souvent qu’une méthode rencontre une erreur sans savoir comment la traiter correctement. Par exemple, une méthode lit un fichier, mais ne sait pas quoi faire si le fichier est absent : demander à l’utilisateur ? Terminer le programme ? Essayer un autre fichier ? Dans de tels cas, la méthode peut « transférer la responsabilité » à l’appelant — c’est-à-dire « propager » l’exception plus loin dans la chaîne des appels.
Propagation d’exception — c’est un mécanisme permettant à une méthode de ne pas gérer l’erreur elle-même, mais d’informer le code appelant : « J’ai un problème ici, débrouille-toi ! »
Analogie : Imaginez que vous êtes employé dans un centre d’appels. Un client vous appelle avec une question à laquelle vous ne savez pas répondre. Au lieu de deviner, vous dites : « Une seconde, je vous passe un spécialiste ». Vous « propagez » la question plus loin.
Mot-clé throws : comment ça fonctionne
En Java, la propagation des exceptions se fait avec le mot-clé throws dans la déclaration de la méthode.
Syntaxe :
returnType methodName(...) throws ExceptionType
{
// code de la méthode
}
Après throws, on indique le type d’exception susceptible de se produire dans cette méthode. C’est comme un avertissement pour les autres développeurs : « Attention ! Cette méthode peut lever une exception de tel type. Soyez prêts ! »
Exemple :
public void readFile(String filename) throws FileNotFoundException
{
FileReader reader = new FileReader(filename); // peut lever FileNotFoundException
// ...
}
Ici, la méthode readFile ne gère pas l’erreur elle-même, mais indique : « Je peux lever FileNotFoundException — que celui qui m’appelle décide quoi faire ».
2. Comment la méthode appelante doit-elle réagir ?
Si vous appelez une méthode déclarée avec throws, vous avez deux options :
- Gérer l’exception avec try-catch
- Propager l’exception plus loin (ajouter aussi throws à votre méthode)
Option 1 : gérer via try-catch
public static void main(String[] args)
{
try
{
readFile("data.txt");
}
catch (FileNotFoundException e)
{
System.out.println("Fichier introuvable : " + e.getMessage());
}
}
Ici, nous interceptons l’exception et décidons nous-mêmes quoi faire (par exemple, afficher un message à l’utilisateur).
Option 2 : propager plus loin
public static void main(String[] args) throws FileNotFoundException
{
readFile("data.txt");
}
La responsabilité du traitement de l’erreur incombe maintenant à celui qui appellera main (en général la JVM elle-même — si l’erreur n’est pas traitée, le programme se termine avec un message d’erreur).
3. Exemple : lecture d’un fichier avec propagation d’exception
Exemple complet avec IOException et traitement au niveau de main :
import java.io.*;
public class FileDemo
{
// La méthode déclare qu’elle peut lever IOException
public static void printFirstLine(String filename) throws IOException
{
BufferedReader reader = new BufferedReader(new FileReader(filename));
String line = reader.readLine();
System.out.println("Première ligne : " + line);
reader.close();
}
public static void main(String[] args)
{
try
{
printFirstLine("nofile.txt");
}
catch (IOException e)
{
System.out.println("Erreur lors de la lecture du fichier : " + e.getMessage());
}
}
}
La méthode printFirstLine ne sait pas quoi faire si le fichier est absent — elle se contente de propager l’exception. Dans main, nous interceptons l’erreur et affichons un message.
4. Nuances utiles
Quand et pourquoi utiliser la propagation des exceptions ?
- Quand une méthode ne peut pas ou ne doit pas décider comment gérer l’erreur (par exemple, du code de bibliothèque).
- Quand le traitement de l’erreur dépend du contexte (dans un cas, terminer le programme ; dans un autre, essayer un autre fichier).
- Pour ne pas encombrer le code de try-catch inutiles là où ce n’est pas nécessaire.
Bonne pratique : Propagez les exceptions si vous ne pouvez pas les traiter de manière pertinente. Ne capturez pas des exceptions juste pour la forme !
Il est possible de propager plusieurs exceptions
public void process() throws IOException, SQLException
{
// ...
}
Exceptions checked et unchecked : rappel
Checked exceptions (par exemple, IOException, SQLException) — le compilateur exige qu’elles soient traitées ou propagées.
Unchecked exceptions (par exemple, NullPointerException, IllegalArgumentException) — le compilateur n’en exige pas le traitement ; on peut ne pas les mentionner dans throws.
5. Erreurs typiques lors de la propagation des exceptions
Erreur n° 1 : vous avez oublié de déclarer throws pour une exception checked.
Si une méthode peut lever une exception checked, mais que vous ne l’avez ni déclarée dans throws ni traitée via try-catch, le compilateur signalera une erreur.
Erreur n° 2 : vous interceptez l’exception sans la traiter.
Écrire catch (Exception e) {} — mauvaise pratique ! Il vaut mieux propager l’exception si vous ne savez pas quoi en faire.
Erreur n° 3 : vous propagez un type trop général.
Si une méthode ne peut lever que FileNotFoundException, n’écrivez pas throws Exception — cela complique la compréhension du code.
Erreur n° 4 : vous mentionnez des exceptions unchecked dans throws.
Cela n’a pas de sens d’écrire throws NullPointerException — le compilateur ne l’exige pas et cela n’aide pas au traitement des erreurs.
GO TO FULL VERSION