Gestion des exceptions en JAVA

Ce TP porte sur la gestion des exceptions en Java. Il permet de s’initier à la capture et au traitement des exceptions à l’aide des blocs try/catch, de tester la création d’exceptions personnalisées, et de comprendre l’importance de la gestion fine des erreurs dans un programme. Pour réaliser ce TP, vous aurez besoin d’un environnement de développement Java, comme Eclipse, et de connaissances de base en programmation Java.

Objectifs

• S’initier à la capture et au traitement des exceptions avec les blocs try/catch.
• Tester la création et l’utilisation d’exceptions personnalisées.
• Comprendre l’importance du bloc finally dans la gestion des ressources.
• Appliquer la gestion d’exceptions dans des cas pratiques comme la validation d’adresses IP ou l’authentification.

Prérequis et installation

• Un environnement de développement Java, par exemple Eclipse.
• Connaissances de base en Java : variables, méthodes, classes, lecture au clavier.
• Notions élémentaires sur les exceptions Java et les blocs try/catch.

Exercice 1 : Initiation au traitement des exceptions

Vous commencez avec un programme simple qui divise deux entiers saisis au clavier. Le programme ne vérifie pas si le diviseur est nul, ce qui provoque une exception à l’exécution.

1. Lancez le programme ExceptionTest.java et saisissez une valeur nulle pour b.
2. Observez si le programme s’exécute correctement, si le message "Fin du programme" apparaît, et quelle exception est levée.

Ensuite, modifiez le programme pour entourer la division par un bloc try/catch afin d’attraper l’exception ArithmeticException :

try {
  res = a / b;
  System.out.println(a + " / " + b + " = " + res);
} catch (ArithmeticException e) {
  System.out.println("oops ! un problème dans la division");
  System.out.println("le message officiel est " + e.getMessage());
}

Relancez le programme avec b = 0 et vérifiez :

• Si le message indiquant un problème dans la division s’affiche.
• Si le message "Fin du programme" apparaît.
• Quel est le message officiel de l’exception.

Ajoutez ensuite un bloc finally :

finally {
  System.out.println("le bloc finally sera toujours exécuté");
  System.out.println("c'est là qu'on fermera par exemple les fichiers");
}

Relancez le programme avec b = 0 et vérifiez que le bloc finally s’exécute toujours.

Pour tester le comportement du bloc finally sans gestion d’exception, commentez le bloc catch et relancez le programme avec b = 0. Vérifiez que le bloc finally s’exécute malgré l’absence de traitement de l’exception.

Enfin, testez la saisie d’une lettre au lieu d’un nombre et observez quelle exception est levée. Corrigez le programme en intégrant la lecture au clavier dans un bloc try/catch pour gérer cette exception.

Exercice 2 : Utilisation des exceptions avec parseInt

La méthode parseInt convertit une chaîne de caractères en entier et peut lever une exception NumberFormatException si la chaîne n’est pas un entier valide.

Utilisez cette méthode pour calculer la somme de tous les entiers passés en arguments de la ligne de commande, en ignorant les autres arguments.

Exercice 3 : Exceptions personnalisées et constructeurs

Vous allez créer une classe adresseIP représentant une adresse IP composée de 4 octets.

1. Écrivez la classe adresseIP.java avec un attribut tableau d’entiers nommé octet.
2. Créez un constructeur qui initialise ce tableau avec 4 entiers (o1, o2, o3, o4) passés en paramètres.
3. Redéfinissez la méthode toString() pour afficher l’adresse IP sous la forme 192.168.10.37.
4. Dans la méthode main, créez une instance d’adresse IP et affichez-la.

Pour garantir que chaque octet est compris entre 0 et 255, vous devez :

1. Définir une classe d’exception personnalisée ExceptionAdrIP dérivant de Exception.
2. Modifier le constructeur de adresseIP pour qu’il lance une ExceptionAdrIP si un octet est hors de la plage 0-255.
3. Dans la méthode main, gérer cette exception pour afficher un message d’erreur indiquant quel octet est incorrect.

Exercice 4 : Exceptions personnalisées et gestion fine

Ce dernier exercice traite des failles de sécurité liées à la saisie utilisateur, notamment les dépassements de taille sur login et mot de passe.

Vous devez implémenter plusieurs classes d’exceptions :

• WrongLoginException : levée lorsque le login est incorrect.
• WrongPwdException : levée lorsque le mot de passe est erroné.
• WrongInputLength : levée lorsque le login ou le mot de passe dépasse 10 caractères.

La classe principale Authentification doit :

• Définir les constantes LoginCorrect et PwdCorrect initialisées respectivement à "scott" et "tiger".
• Implémenter les méthodes getUserLogin() et getUserPwd() pour lire les saisies clavier, susceptibles de lever les exceptions ci-dessus.
• Dans le constructeur, appeler ces méthodes pour récupérer login et mot de passe.

Enfin, créez la classe TestAuthentification avec une méthode main() qui :

• Effectue une boucle d’authentification tant que les saisies sont incorrectes.
• Gère les exceptions avec une granularité fine, pour informer précisément l’utilisateur des erreurs.

Résultats attendus

• Dans l’exercice 1, la division par zéro doit être interceptée sans arrêter brutalement le programme, avec affichage d’un message d’erreur clair et exécution systématique du bloc finally.
• La saisie d’une lettre lors de la lecture d’un entier doit être gérée par une exception InputMismatchException ou similaire.
• Dans l’exercice 2, la somme des entiers passés en arguments doit être calculée correctement, en ignorant les arguments non numériques.
• Dans l’exercice 3, la création d’une adresse IP avec des octets hors plage doit lever une exception personnalisée, empêchant la création et affichant un message d’erreur.
• Dans l’exercice 4, les exceptions spécifiques doivent être levées selon le type d’erreur de saisie (login incorrect, mot de passe incorrect, dépassement de longueur), et le programme doit continuer à demander les informations tant que l’authentification échoue.

Pièges courants

• Ne pas entourer toutes les opérations susceptibles de lever une exception dans un bloc try, notamment la lecture au clavier.
• Oublier de fermer le scanner dans le bloc finally, ce qui peut entraîner des fuites de ressources.
• Ne pas gérer correctement les exceptions personnalisées dans le main, ce qui peut provoquer l’arrêt du programme.
• Dans l’exercice 3, ne pas vérifier la validité de chaque octet avant de les affecter, ce qui rend la gestion des erreurs inefficace.
• Dans l’exercice 4, mélanger la gestion des différentes exceptions dans un seul catch, ce qui empêche une gestion fine et adaptée des erreurs.