Les exceptions

1. Analyser une stacktrace

Exécutons le programme suivant :

fun main() 
{ 
 val result = 12 / 0 
 println(result) 
} 

Jetons un coup d’œil sur le terminal :

Exception in thread "main" java.lang.ArithmeticException: / by zero 
      at MainKt.main(Main.kt:3) 
      at MainKt.main(Main.kt) 

Ces lignes rouges forment ce qu’on appelle une stacktrace.

Les stacktraces sont générées dès qu’une exception se produit dans un programme. Et les exceptions se produisent dès qu’un programme détecte un comportement anormal.

Il existe des milliers de raisons qui peuvent provoquer des exceptions lors de l’exécution d’un programme. Par exemple, une division par 0, la manipulation d’une variable ou d’un objet non initialisé...

1. Capturer une exception

Comme on l’a vu, certaines exceptions sont récupérables, c’est-à-dire qu’elles ne devraient pas provoquer l’arrêt du programme. Plutôt que de planter, le programme compose avec l’exception et avertit l’utilisateur que l’opération demandée n’a pas pu aboutir.

Reprenons le programme qui effectue une division par 0 :

fun main() 
{ 
 val result = 12 / 0 
 println(result) 
} 

Pour capturer une exception dans un programme, il convient d’utiliser ce que l’on appelle un bloc try catch.

Qu’est-ce exactement ?

Comme son nom le laisse deviner, ce bloc permet d’essayer d’exécuter une instruction et de capturer une potentielle exception si jamais tout ne se passe pas comme prévu.

Voici la syntaxe de ce bloc, elle est relativement simple :

try 
{ 
 //... 
} 
catch (exception: Exception) 
{ 
 //... 
} 

À l’intérieur du bloc try, on écrit l’ensemble des instructions qui peuvent provoquer une exception. Au niveau du bloc catch, on renseigne le type de l’exception que l’on souhaite capturer. Toujours dans ce bloc, il est alors possible de manipuler l’exception à travers une variable afin d’obtenir les informations qui composent, par exemple la stacktrace ou encore un message.

Dans le programme effectuant une division par 0, on souhaite capturer une exception de type ArithmeticException.

fun main() 
{ 
 println("Starting the program") 
 
 try 
{ 
   val result = 12 / 0 
   println("The result is $result") 
 } ...

1. Quand lever une exception ?

Le but d’une exception est d’indiquer que le programme ne s’est pas déroulé normalement. Il n’y a pas forcément de règles sur la façon dont un programme doit lever des exceptions.

Prenons l’exemple d’une fonction qui accepte deux nombres entiers strictement positifs en arguments, qui les additionne et qui renvoie le résultat. Puisque cette méthode attend des nombres strictement positifs en arguments, elle doit absolument vérifier que les arguments sont supérieurs à 0. Quand l’un des deux arguments est négatif ou nul, on trouve, suivant les programmeurs, plusieurs logiques. Certains lèveront une exception pour indiquer que l’un des paramètres ne remplit pas tous les prérequis, tandis que d’autres ne lèverent pas une exception, mais renvoient par exemple un résultat null ou négatif pour indiquer qu’une erreur s’est produite.

En programmation, les exceptions font souvent peur aux développeurs qui préfèrent éviter leur utilisation plutôt que de composer avec elles et de les utiliser dans leurs programmes.

2. Utiliser le mot-clé throw

Lever une exception est très simple puisqu’il suffit d’utiliser le mot-clé throw suivi d’une instance de l’exception à lever.

Revenons à la fonction qui accepte deux nombres entiers strictement positifs en arguments, qui les additionne et qui renvoie le résultat. Avant de procéder au calcul, cette fonction doit vérifier que les arguments sont strictement positifs. Si ce n’est pas le cas, une exception doit être levée.

fun add(a: Int, b: Int): Int 
{ 
 if (a <= 0) 
 { 
   throw IllegalArgumentException("a <= 0") 
 } 
 
 if (b <= 0) 
 { 
   throw IllegalArgumentException("b <= 0") 
 } 
 
 return a + b 
} 

La chaîne...