1. Dérogations
>
Enfin, les programmeurs ont pensé à normaliser et à automatiser la gestion des erreurs. Cela s'est produit lorsque les exceptions ont été inventées. Désormais, le mécanisme d'exception gère 80 % des situations exceptionnelles.
Si un chercheur proposait des exceptions, c'était probablement le sujet de sa thèse de doctorat. Si un programmeur l'a inventé, il a peut-être reçu une tape amicale dans le dos d'un collègue : "Ça va, mon frère."
Lorsqu'une erreur se produit dans un programme Java, telle qu'une division par 0
, des choses merveilleuses se produisent :
La première étape
Un objet d'exception spécial est créé, qui contient des informations sur l'erreur qui s'est produite.
Tout en Java est un objet, et les exceptions ne sont pas des exceptions 🙂 Les objets d'exception ont leurs propres classes, et la seule chose qui les distingue des classes ordinaires est qu'ils héritent de la classe Throwable
.
Deuxième étape
L'objet d'exception est "levé". Peut-être que la formulation ici pourrait être meilleure. "Lancer une exception" revient plus à déclencher une alarme incendie ou à déclencher une alerte "DEFCON 1".
Lorsqu'une exception est lancée sur la machine Java, le fonctionnement normal du programme s'arrête et les "protocoles d'urgence" commencent.
Troisième étape
La méthode dans laquelle l'exception a été levée se termine immédiatement. L'exception est transmise à la méthode appelante, qui se termine également immédiatement. Et ainsi de suite dans la chaîne jusqu'à main
la sortie de la méthode. Lorsque la main
méthode se termine, le programme aussi.
Exemple:
Code | Sortie console |
---|---|
|
|
Une exception se produit à la ligne 20 : division par 0. La machine Java crée immédiatement une exception — un ArithmeticException
objet et le « lance » à la méthode.
La divide()
méthode se termine immédiatement, donc nous ne voyons jamais la chaîne : Rien de grave ne s'est produit : 0. Le programme retourne à la endTheWorld()
méthode, et la situation se répète : il y a une exception non gérée dans le système, ce qui signifie que la endTheWorld()
méthode se termine également de manière anormale. Ensuite, la main
méthode se termine et le programme s'arrête.
A quoi servent ces exceptions ? Eh bien, vous pouvez écrire votre propre code pour intercepter des types particuliers d'exceptions et écrire votre propre logique pour gérer des situations exceptionnelles.
2. Attraper les exceptions :try-catch
Java dispose d'un mécanisme de capture d'exception qui vous permet d'arrêter cet arrêt anormal des méthodes. Il ressemble à ceci :
try
{
// Code where an exception might occur
}
catch(ExceptionType name)
{
// Exception handling code
}
Cette construction s'appelle un try-catch
bloc.
Le code où des exceptions peuvent se produire est entouré d'accolades, précédé du mot try
.
Après les accolades, nous avons le catch
mot clé et, entre parenthèses, la déclaration d'une variable d'exception . Elle est suivie d' accolades qui enveloppent le code à exécuter si une exception du type spécifié se produit .
Si aucune exception n'est levée lors de l'exécution du " code primaire ", alors le code à l'intérieur du bloc catch ne sera pas exécuté. Si une exception se produit, elle le sera (si le type de l'exception levée est le même que le type de la variable entre parenthèses).
Exemple:
Code | Sortie console |
---|---|
|
|
3. catch
Blocs multiples
En théorie, toutes sortes d'exceptions peuvent être lancées dans un bloc de code. Certains que vous voudrez gérer d'une manière, d'autres d'une autre manière, et d'autres encore, vous déciderez de ne pas les gérer du tout.
Les développeurs Java ont décidé de vous aider et de vous laisser écrire non pas un mais plusieurs catch
blocs après le try
bloc.
try
{
// Code where an exception might occur
}
catch (ExceptionType1 name1)
{
// Code for handling ExceptionType1
}
catch (ExceptionType2 name2)
{
// Code for handling ExceptionType2
}
catch (ExceptionType3 name3)
{
// Code for handling ExceptionType3
}
Exemple:
Code | Sortie console |
---|---|
|
|
4. Ordre des catch
blocs
Les exceptions qui se produisent dans un try
bloc ne peuvent être interceptées que par un seul catch
bloc. Vous ne pouvez pas avoir une situation de gestion des exceptions où le code de plusieurs catch
blocs est exécuté.
Mais l'ordre des blocs est important.
Vous pouvez avoir une situation où une exception peut être interceptée par plusieurs blocs. Si tel est le cas, l'exception sera interceptée par le bloc catch qui vient en premier (le plus proche du try
bloc).
Comment pouvez-vous avoir une situation où plusieurs blocs catch peuvent intercepter la même exception ?
Toutes les exceptions appartiennent à une seule hiérarchie d'héritage — voir le diagramme.
Un ArithmeticException
objet peut être affecté à une variable dont le type est ArithmeticException
ou à l'une de ses classes ancêtre : RuntimeException
, Exception
et Throwable
— voir le diagramme.
Nous parlerons davantage des classes d'héritage et d'ancêtre au niveau 21.
Ce code compilera très bien:
Avantages de l'héritage : |
---|
|
Vous pouvez donc attraper un ArithmeticException
avec l'un des 4 catch
blocs ci-dessus.
Exemple 1:
Code | Sortie console |
---|---|
|
|
Dans cet exemple, le ArithmeticException
peut être capturé à la fois par les blocs catch (Exception e)
et catch (ArithmeticException e)
. Il sera attrapé par le bloc le plus proche du try
bloc - le premier catch
bloc.
Pour éviter les surprises, il est préférable de placer catch
des blocs qui peuvent intercepter presque toutes les exceptions vers la fin de la liste des catch
blocs.
Le Throwable
type est généralement capable d' attraper toutes les exceptions possibles en Java . Si vous le mettez dans le premier catch
bloc, le code ne se compilera pas, car le compilateur sait qu'il existe des blocs de code inaccessibles.