Exceptions.md

@@ -216,8 +216,13 @@ public void push(int element) throws StackIsFullException, NegativeElementExcept
 
 # Capture et traitement d’exceptions
 
-:book: Dans une méthode où des appels de méthode peuvent se traduire par des remontées d’exceptions et **où un traitement d’erreur est prévu** (on sait gérer l'erreur), il est obligatoire de **capturer les exceptions**, via la clause `try` / `catch` / `finally`.
+:book: Dans une méthode où des appels de méthode peuvent se traduire par des remontées d’exceptions et **où un traitement d’erreur est prévu** (on sait gérer l'erreur), il est obligatoire de **capturer les exceptions**, via la clause `try` / `catch` / `finally` :
+- le bloc `try` contient les instructions susceptibles de soulever des exceptions
+- si une exception remonte d'une des instructions du bloc `try`, l'exécution du bloc `try` s'arrête et les instructions du bloc `catch` correspondant au type d'exception sont alors exécutées.
+- sinon, on exécute les instructions suivantes du bloc `try`, puis on poursuit par les instructions situées après le bloc `catch`.
+- le bloc `finally` est optionnel et contient les instructions qui seront exécutées quoi qu'il arrive (qu'on ait exécuté le bloc `catch` ou non).
 
+L'exemple ci-dessous illustre ce mécanisme :
 
 ```java
 public static void main(String[] args) {
@@ -230,3 +235,14 @@ public static void main(String[] args) {
   System.out.println(stack.toString());
 }
 ```
+
+:bulb: Ici, l'appel au constructeur (qui peut soulever l'exception `InvalidCapacityException`) est effectué dans le bloc `try`. Si l'exception est soulevé, l'instruction `System.exit(1)`est exécutée. Celle-ci permet de terminer l'application avec un code indiquant une terminaison anormale. Sinon, l'exécution se poursuit par l'affichage sur la console de la représentation texte de la pile.
+
+:book: si les instructions du bloc `try`peuvent faire remonter plusieurs types différents d'exception, alors il est possible de définir un bloc `catch` par exception de sorte de différencier le traitement d'erreur si besoin. Il est aussi possible de n'écrire qu'un seul bloc `catch` capturant une exception d'un type qui englobe tous les types de ces exceptions (par exemple `Exception`), si le traitement d'erreur est le même dans tous les cas.
+
+```java
+
+try { stack.empiler(value); }
+catch (FullStackException e1) { ... }
+catch (NegativeElementException e2) { ... }
+  catch (UnexpectedCapacityException e) { System.exit(1); }