Les exceptions dans Java sont groupées en trois types de classes :

• les erreurs (classe : Error),
• les exceptions non-vérifiées (unchecked exceptions) par le compilateur (classe : RuntimeException),
• et les exceptions vérifiées (checked exceptions) par le compilateur (classe : Exception).

java.lang.Object | | java.lang.Throwable | _______________|_______________ | | \_/ \_/ java.lang.Error java.lang.Exception | ____________________|____________________ | | \_/ \_/ java.lang.RuntimeException [Autres sous-classes de la classe Exception]
Les exceptions vérifiées et non vérifiées par le compilateur (checked/unchecked exceptions) :

• Les exceptions vérifiées par le compilateur (checked exceptions) sont des exceptions pour les quelles le compilateur va générer une erreur de compilation s'elles ne sont pas gérées par le code. Cela concerne toutes les exceptions qui sont de type (ou sous type de) Exception mais qui ne sont pas du type (ou sous type de) RuntimeException.
  
  
• Les exceptions non vérifiées par le compilateur (unchecked exceptions) sont les exceptions de type Throwable, de type (ou sous type de) Error, ou de type (ou sous type de) RuntimeException.
  

Pour gérer une exception on utilise le bloc de code try/catch :
package com.mtitek.exceptions; public class MyTest1 { public static void main(String[] args) { System.out.println("main: start"); try { int a = 10 / 0; } catch (Exception e) { e.printStackTrace(); } System.out.println("main: end"); } }
Résultat d'exécution du code : main: start java.lang.ArithmeticException: / by zero at com.mtitek.exceptions.MyTest1.main(MyTest1.java:7) main: end
NOTE : L'exception ArithmeticException est une sous-classe de la classe RuntimeException (unchecked exception), et donc le compilateur ne se plaindra pas si on ne gère pas cette exception par un bloc try/catch :
package com.mtitek.exceptions; public class MyTest1 { public static void main(String[] args) { System.out.println("main: start"); int a = 10 / 0; System.out.println("main: end"); } }
Résultat d'exécution du code : main: start Exception in thread "main" java.lang.ArithmeticException: / by zero at com.mtitek.exceptions.MyTest1.main(MyTest1.java:7)
Cette fois ci, lorsque la JVM a rencontré l'exception, le programme a terminé son exécution.

NOTE : La gestion des exceptions permet d'arrêter la propagation des exceptions dans la pile d'exécution (appels de méthodes).
En absence de la gestion des exceptions, elles peuvent être propagées jusqu'à la méthode principale (main) ; ce qui signifie l'arrêt du programme s'elles ne sont pas gèrer par cette méthode.

Remarque : Bien que la gestion des exceptions est possible pour toutes les exceptions de type (ou sous type de) Throwable, elle n'a cependant un vrai intérêt que pour les exceptions de type (ou sous type de) Exception. En fait, le programme doit gérer seulement les exceptions applicatives, et rare les cas où on s'intéressera à gérer les exceptions de type Error (erreurs JVM par exemple).

Les clauses try, catch, finally permettent de gérer des exceptions :

• try : détermine le bloc du code qui est susceptible de lancer une exception.
  
  
• catch : permet d'attraper une exception lancée par le bloc du code de la clause try.
  
  
• finally : permet de faire des actions spécifiques suite à l'exécution du bloc du code de la clause try et, si c'est le cas, de la clause catch.
  

Les règles d'utilisation des clauses try, catch, finally sont :

• La clause try doit être utilisée avec la clause catch et/ou finally. Si la clause try n'est pas suivie par au moins une des deux clauses catch et finally, le compilateur générera une erreur de compilation.
  try { int a = 10 / 0; } // Syntax error, insert "Finally" to complete BlockStatements
  
• Chaque gestion d'exception peut avoir autant de clauses catch si nécessaire.
  try { // ... } catch (ArithmeticException e) { // ... } catch (Exception e) { // ... }
  
• Le type de l'exception d'une clause catch doit avoir un type d'exception différents des autres clauses catch. Sinon le compilateur va générer une erreur de compilation :
  try { // ... } catch (Exception e) { // ... } catch (Exception e) { // Unreachable catch block for Exception. It is already handled by the catch block for Exception // ... }
  
• Le type de l'exception d'une clause doit être un sous type ou un type différent des types des autres clauses définies au dessous de cette clause. Sinon le compilateur va générer une erreur de compilation :
  try { // ... } catch (Exception e) { // ... } catch (ArithmeticException e) { // Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception // ... }
  
• Lorsque le bloc d'une clause est exécuté, les autres clauses ne seront pas exécutées, et cela même si le code de cette clause déclenche lui aussi une exception. La nouvelle exception doit être gérer à l'intérieur d'un autre bloc try catch.
  public static void main(String[] args) { System.out.println("main: start"); try { // outer try try { // inner try int a = 10 / 0; // La JVM va déclencher une première exception ICI. } catch (ArithmeticException e) { System.out.println("inner try : catch ArithmeticException"); int b = 10 / 0; // La JVM va déclencher une deuxième exception ICI. } catch (Exception e) { System.out.println("inner try : catch Exception"); // Ce bloc ne sera pas exécuté ni par la première exception ni par la deuxième exception } } catch (Exception e) { System.out.println("outer try : catch Exception"); // La deuxième exception sera attrapée ICI } System.out.println("main: end"); }
  Résultat d'exécution du code : main: start inner try : catch ArithmeticException outer try : catch Exception main: end
  
• La clause finally peut être utilisée avec ou sans des clauses catch.
  Une clause finally sans les clauses catch peut être utile dans les cas où on veut faire un traitement spécial sans pour autant arrêter la propagation de l'exception.
  public static void main(String[] args) { System.out.println("main: start"); try { // outer try try { // inner try int a = 10 / 0; // La JVM va déclencher une exception ICI. } finally { System.out.println("inner try : finally"); } } catch (Exception e) { System.out.println("outer try : Exception"); } System.out.println("main: end"); }
  Résultat d'exécution du code : main: start inner try : finally outer try : Exception main: end
  
• Le code de la clause finally va toujours être exécuté peu importe s'il y a des clauses catch ou pas.
  Il va être exécuté même si le code d'une clause est exécuté et que celui-ci lance une nouvelle exception.
  public static void main(String[] args) { System.out.println("main: start"); try { // outer try try { // inner try int a = 10 / 0; // La JVM va déclencher une première exception ICI. } catch (ArithmeticException e) { System.out.println("inner try : catch ArithmeticException"); int b = 10 / 0; // La JVM va déclencher une deuxième exception ICI. } finally { System.out.println("inner try : finally"); } } catch (Exception e) { System.out.println("outer try : Exception"); } System.out.println("main: end"); }
  Résultat d'exécution du code : main: start inner try : catch ArithmeticException inner try : finally outer try : Exception main: end

Il est possible de lancer une exception par le code, par exemple lorsqu'on rencontre une situation incorrecte lors de l'exécution du code. package com.mtitek.exceptions; public class MyTest1 { public static void main(String[] args) { System.out.println("main: start"); try { int v1 = 10; int v2 = 0; if(v2 == 0) { throw new ArithmeticException("Attention, division entière / 0 !"); } else { int v = v1 / v2; } } catch (ArithmeticException e) { e.printStackTrace(); } System.out.println("main: end"); } }
Résultat d'exécution du code : main: start java.lang.ArithmeticException: Attention, division entière / 0 ! at com.mtitek.exceptions.MyTest1.main(MyTest1.java:12) main: end
Cet exemple est inutile, mais on y voit bien l'utilisation du mot clé throw pour lancer une exception applicative.

Une méthode qui lancent des exceptions (ou qui fait appel à des méthodes qui sont susceptibles de lancer eux même des exceptions) peut déclarer ces exceptions et ainsi les autres méthodes qui font appels à cette méthode pourront savoir qu'elle lance des exceptions et ainsi les gérer ou les déclarer à leurs tours.

Bien que la déclaration peut inclure tous les types des exceptions (Throwable, Error, Exception, RuntimeException), le compilateur ne fait la vérification que pour les exceptions de type Exception. C'est la même règle qu'on a vu ci-dessus pour la gestion des exceptions vérifiables par le compilateur. En fait on vient de la généraliser, puisque la règle en Java est : gérer ou déclarer une exception, sinon le compilateur va générer une erreur de compilation.

Pour déclarer une exception on utilise le mot clé throws comme suit : throws Exception
Pour déclarer plusieurs exceptions, on les sépare par des virgules comme suit : throws ArithmeticException, Exception
package com.mtitek.exceptions; public class MyTest1 { public static void main(String[] args) { System.out.println("main: start"); try { int v1 = divide(10, 0); } catch (Exception e) { e.printStackTrace(); } System.out.println("main: end"); } private static int divide(int p1, int p2) throws Exception { // déclaration de l'exception if(p2 == 0) { throw new Exception("Attention, division entière / 0 !"); } else { return p1 / p2; } } }
Résultat d'exécution du code : main: start java.lang.Exception: Attention, division entière / 0 ! at com.mtitek.exceptions.MyTest1.divide(MyTest1.java:18) at com.mtitek.exceptions.MyTest1.main(MyTest1.java:8) main: end
Une méthode doit soit gérer ou déclarer les exceptions déclarées par les méthodes appelées par le code de cette méthode (cella s'applique uniquement aux exceptions vérifiables par le compilateur).

Dans l'exemple précédent la méthode main gère l'exception lancée par la méthode divide, au cas contraire la méthode main doit déclarer elle aussi cette exception (sinon le compilateur va générer une erreur de compilation).

package com.mtitek.exceptions; public class MyTest1 { public static void main(String[] args) throws Exception { System.out.println("main: start"); int v1 = divide(10, 0); System.out.println("main: end"); } private static int divide(int p1, int p2) throws Exception { if(p2 == 0) { throw new Exception("Attention, division entière / 0 !"); } else { return p1 / p2; } } }
Résultat d'exécution du code : main: start Exception in thread "main" java.lang.Exception: Attention, division entière / 0 ! at com.mtitek.exceptions.MyTest1.divide(MyTest1.java:14) at com.mtitek.exceptions.MyTest1.main(MyTest1.java:7)
Notez que le code n'a pas terminé son exécution à cause que l'exception n'a pas été gérer par un bloc try catch et comme la méthode main et la dernière méthode de la pile d'exécution, la JVM arrête donc la propagation de l'exception et met fin à l'exécution du programme.

Il faut signaler que les exceptions sont des classes qui héritent de la classe Object.

La création d'une nouvelle exception est utile lorsqu'on veut gérer un type particulier d'exception et ainsi la distinguer des autres exceptions.

La classe de la nouvelle exception doit étendre une des classes Throwable, Error, ou Exception ou n'import quelle autre classe qui hérite de ces classes.

Dans l'exemple suivant:
Pas besoin de gérer l'exception ArithmeticException car non vérifiées par le compilateur.
Pas besoin de gérer l'exception SmallNumberException car déclarée par la méthode main.
Mais attention : Si les exceptions SmallNumberException et ArithmeticException ne sont pas gérées, l'exécution du programme pourrait s'arrêter avant d'atteindre la fin du code si ces exceptions sont lancées.

public class BigNumberException extends Exception { public BigNumberException() { super("Big Number Exception"); } }
public class SmallNumberException extends Exception { public SmallNumberException() { super("Small Number Exception"); } }
package com.mtitek.exceptions; public class MyTest1 { public static void main(String[] args) throws SmallNumberException { System.out.println("main: start"); try { int v1 = divide(10, 0); } catch (BigNumberException e) { e.printStackTrace(); } catch (SmallNumberException e) { e.printStackTrace(); } catch (ArithmeticException e) { e.printStackTrace(); } try { int v1 = divide(100, 2); } catch (BigNumberException e) { e.printStackTrace(); } catch (SmallNumberException e) { e.printStackTrace(); } catch (ArithmeticException e) { e.printStackTrace(); } try { int v1 = divide(-10, 2); } catch (BigNumberException e) { e.printStackTrace(); } // Dans le cas de cet exemple, l'exécution du programme va s'arrêter avant d'atteindre la fin du code. System.out.println("main: end"); } private static int divide(int p1, int p2) throws SmallNumberException, BigNumberException { if(p2 == 0) { throw new ArithmeticException("Attention, division entière / 0 !"); // Pas besoin de déclarer cette exception car non vérifiées par le compilateur } else if(p1 < 0) { throw new SmallNumberException(); } else if(p1 > 10) { throw new BigNumberException(); } else { return p1 / p2; } } }
Résultat d'exécution du code : main: start java.lang.ArithmeticException: Attention, division entière / 0 ! at com.mtitek.exceptions.MyTest1.divide(MyTest1.java:43) at com.mtitek.exceptions.MyTest1.main(MyTest1.java:8) com.mtitek.exceptions.BigNumberException: Big Number Exception at com.mtitek.exceptions.MyTest1.divide(MyTest1.java:47) at com.mtitek.exceptions.MyTest1.main(MyTest1.java:20) Exception in thread "main" com.mtitek.exceptions.SmallNumberException: Small Number Exception at com.mtitek.exceptions.MyTest1.divide(MyTest1.java:45) at com.mtitek.exceptions.MyTest1.main(MyTest1.java:32)