Exercice Java Corrigé – Gestion Des Exceptions

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Entrez le numérateur : ");
        double numerateur = scanner.nextDouble();

        System.out.print("Entrez le diviseur : ");
        double diviseur = scanner.nextDouble();

        try {
            if (diviseur == 0) {
                throw new ArithmeticException("Erreur : Division par zéro !");
            }
            double resultat = numerateur / diviseur;
            System.out.println("Le résultat de la division est : " + resultat);
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        } finally {
            scanner.close();
        }
    }
}

Sortie:

Entrez le numérateur : 5
Entrez le diviseur : 0
Erreur : Division par zéro !

Explication:

• Bloc try : Il essaie de vérifier si le diviseur est zéro. Si c’est le cas, il lève une ArithmeticException avec un message d’erreur approprié.
• Calcul de la division : Si le diviseur n’est pas zéro, il effectue la division et affiche le résultat.
• Bloc catch : Attrape l’exception levée et affiche le message d’erreur.
• Bloc finally : Ferme le scanner pour libérer les ressources.

public class Main{
  public static void main(String[] args) {
    int n = 4;
    check(n);
    n = 3;
    check(n);
  }

  public static void check(int n) {
    try {
      if (n % 2 != 0) {
         throw new IllegalArgumentException(n +" est impaire.");
      }
      System.out.println(n +" est paire.");
    } catch (IllegalArgumentException e) {
      System.out.println("Erreur: "+ e.getMessage());
    }
  }
}

Sortie:

4 est paire.
Erreur: 3 est impaire.

Explication:

Si une exception se produit dans le bloc try, elle est rattrapée par le bloc catch, qui gère l’exception IllegalArgumentException. Dans ce cas, le message d’erreur « Error : [message d’exception] » est affiché.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Entrez un nombre : ");
        String input = scanner.nextLine();

        try {
            // Tente de convertir la chaîne en entier
            int nombre = Integer.parseInt(input);
            System.out.println("Le nombre que vous avez entré est : " + nombre);
        } catch (NumberFormatException e) {
            // Attrape l'exception si la conversion échoue
            System.out.println("Erreur : Veuillez entrer un nombre valide.");
        } finally {
            scanner.close();
        }
    }
}

Sortie:

Entrez un nombre : abc
Erreur : Veuillez entrer un nombre valide.

Explication:

• Lecture de l’entrée utilisateur : Le programme demande à l’utilisateur d’entrer un nombre sous forme de chaîne.
• Bloc try : Il essaie de convertir cette chaîne en entier à l’aide de Integer.parseInt(). Si l’entrée est une chaîne qui ne peut pas être convertie en entier (comme « abc » ou « 12.34 »), une NumberFormatException sera levée.
• Bloc catch : Attrape la NumberFormatException et affiche un message d’erreur pour informer l’utilisateur qu’il doit entrer un nombre valide.
• Bloc finally : Ferme le scanner pour libérer les ressources.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Création d'un tableau de taille 5
        int[] tableau = new int[5];
        
        // Remplir le tableau avec des valeurs
        for (int i = 0; i < tableau.length; i++) {
            // Remplissage avec des multiples de 10
            tableau[i] = i * 10; 
        }

        System.out.print("Entrez un index pour récupérer la valeur (0 à 4): ");
        try {
            // Lecture de l'index de l'utilisateur
            int index = scanner.nextInt(); 
            // Essayer de récupérer la valeur à cet index
            System.out.println("Valeur à l'index "+ index +" : "+ tableau[index]);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Attraper l'exception si l'index est en dehors des limites
            System.out.println("Erreur: L'index est en dehors des limites du tableau.");
        } catch (Exception e) {
            // Attraper d'autres exceptions possibles
            System.out.println("Erreur: Veuillez entrer un entier valide.");
        } finally {
            scanner.close();
        }
    }
}

Sortie:

Entrez un index pour récupérer la valeur (0 à 4): 5
Erreur: L'index est en dehors des limites du tableau.

Explication:

Bloc try :

• Il essaie de récupérer la valeur à l'index donné.
• Si l'index est inférieur à 0 ou supérieur à 4, une ArrayIndexOutOfBoundsException sera levée.

Bloc catch :

• Le premier catch attrape la ArrayIndexOutOfBoundsException et affiche un message d'erreur approprié.
• Le second catch est une gestion générale pour capturer d'autres exceptions, comme une InputMismatchException si l'utilisateur entre un type de données non valide (par exemple, un caractère).

import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        try {
            System.out.print("Entrez une note (0 à 100) : ");
             // Ligne suivante peut lever InputMismatchException
            int note = scanner.nextInt();
            
            // Vérifier si la note est dans l'intervalle valide
            if (note < 0 || note > 100) {
                throw new IllegalArgumentException("Erreur : La note doit être entre 0 et 100.");
            }

            System.out.println("Vous avez entré la note : " + note);
            
        } catch (InputMismatchException e) {
            // Attrape l'exception si l'utilisateur entre un type de 
            // données non valide
            System.out.println("Erreur : Veuillez entrer un nombre entier valide.");
        } catch (IllegalArgumentException e) {
            // Attrape l'exception si la note est en dehors des 
            // limites
            System.out.println("Erreur : " + e.getMessage());
        } finally {
            System.out.println("Fin du programme.");
            scanner.close(); // Fermer le scanner
        }
    }
}

Sortie:

Entrez une note (0 à 100): quatre-vingt
Erreur: Veuillez entrer un nombre entier valide.
Fin du programme.

Explication:
Bloc try:

• Demande à l'utilisateur d'entrer une note.
• Lit la note avec nextInt().
• Vérifie si la note est dans l'intervalle valide (0 à 100). Si ce n'est pas le cas, une IllegalArgumentException est levée.

Bloc catch:

• Gère InputMismatchException pour une entrée non valide.
• Gère IllegalArgumentException pour une note en dehors de l'intervalle valide.

Bloc finally: Indique que le programme se termine et ferme le scanner.

import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        try {
            System.out.print("Entrez un nombre décimal : ");
            // Lire l'entrée sous forme de chaîne
            String input = scanner.next(); 
            // parseDouble peut lever NumberFormatException
            double nombreDecimal = Double.parseDouble(input); 

            System.out.println("Le nombre décimal que vous avez entré est: "+ nombreDecimal);
            
        } catch (NumberFormatException e) {
            // Attrape l'exception si la chaîne ne peut pas être 
            // convertie en nombre
            System.out.println("Erreur: Veuillez entrer un nombre décimal valide.");
        } catch (InputMismatchException e) {
            // Attrape l'exception si l'utilisateur entre un type de 
            // données non valide
            System.out.println("Erreur: Veuillez entrer un type de données valide.");
        } finally {
            System.out.println("Fin du programme.");
            scanner.close(); // Fermer le scanner
        }
    }
}

Sortie:

Entrez un nombre décimal : 15.33
Le nombre décimal que vous avez entré est : 15.33
Fin du programme.

Explication:
Bloc try:

• Demande à l'utilisateur d'entrer un nombre décimal.
• Lit l'entrée sous forme de chaîne.
• Essaie de convertir la chaîne en un nombre décimal avec Double.parseDouble().

Bloc catch:

• Gère NumberFormatException si la chaîne ne peut pas être convertie en un nombre décimal valide.
• Gère InputMismatchException si l'utilisateur entre un type de données non valide.

Bloc finally: Indique que le programme se termine et ferme le scanner.

import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        try {
            System.out.print("Entrez votre âge : ");
            // Ligne suivante peut lever InputMismatchException
            int age = scanner.nextInt(); 
            
            // Vérifier si l'âge est valide
            if (age < 0 || age > 130) {
                throw new IllegalArgumentException("Erreur: L'âge doit être entre 0 et 130.");
            }

            System.out.println("Votre âge est : "+ age);
            
        } catch (InputMismatchException e) {
            // Attrape l'exception si l'utilisateur entre un type de 
            // données non valide
            System.out.println("Erreur: Veuillez entrer un nombre entier valide.");
        } catch (IllegalArgumentException e) {
            // Attrape l'exception si l'âge est en dehors des limites
            System.out.println("Erreur: "+ e.getMessage());
        } finally {
            System.out.println("Fin du programme.");
            scanner.close(); // Fermer le scanner
        }
    }
}

Sortie:

Entrez votre âge : 150
Erreur : L'âge doit être entre 0 et 130.
Fin du programme.

Explication:
Bloc try:

• Demande à l'utilisateur d'entrer son âge.
• Lit l'âge avec nextInt().
• Vérifie si l'âge est valide (entre 0 et 130). Si ce n'est pas le cas, une IllegalArgumentException est levée.

Bloc catch:

• Gère InputMismatchException si l'utilisateur entre une valeur non valide.
• Gère IllegalArgumentException pour un âge hors limites.

Bloc finally: Indique que le programme se termine et ferme le scanner.

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    try {
      readFile("test.txt");
    } catch (FileNotFoundException e) {
      System.out.println("Erreur: "+ e.getMessage());
    }
  }

  public static void readFile(String fileName) throws FileNotFoundException {
    File file = new File(fileName);
    Scanner scanner = new Scanner(file);

    // Lire et traiter le contenu du fichier
    while (scanner.hasNextLine()) {
      String line = scanner.nextLine();
      System.out.println(line);
    }

    scanner.close();
  }
}

Sortie:

Erreur: test.txt (No such file or directory)

Explication:

Dans l'exercice ci-dessus,

• Nous avons une méthode appelée readFile qui prend un paramètre fileName. Pour lire le contenu du fichier, elle crée un objet Scanner à l'aide de la classe File.
• Dans la méthode principale, nous appelons la méthode readFile et fournissons le nom du fichier que nous voulons lire. Si le fichier n'est pas trouvé, une exception FileNotFoundException est levée.
• Dans la méthode readFile, nous déclarons un objet File et l'initialisons avec le nom de fichier donné. Nous créons ensuite un objet Scanner en utilisant le fichier. Si le fichier n'est pas trouvé, une exception FileNotFoundException est levée.
• Un bloc try-catch est utilisé dans la méthode principale pour attraper l'exception FileNotFound et afficher un message d'erreur.

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    try {
      checkFileNotEmpty("test.txt");
      System.out.println("Le fichier n'est pas vide.");
    } catch (FileNotFoundException e) {
      System.out.println("Error: " + e.getMessage());
    } catch (EmptyFileException e) {
      System.out.println("Error: " + e.getMessage());
    }
  }

  public static void checkFileNotEmpty(String fileName) throws FileNotFoundException, EmptyFileException {
    File file = new File(fileName);
    Scanner scanner = new Scanner(file);

    if (!scanner.hasNextLine()) {
      scanner.close();
      throw new EmptyFileException("Le fichier est vide.");
    }

    scanner.close();
  }
}

class EmptyFileException extends Exception {
  public EmptyFileException(String message) {
    super(message);
  }
}

Sortie:

Contenu du fichier (test.txt) :
 
Erreur : Le fichier est vide.

Explication:

Dans l'exercice ci-dessus,

• Le programme comprend deux classes: Main et EmptyFileException.
• La classe Main contient la méthode main, qui sert de point d'entrée au programme.
• Dans la méthode main, nous appelons la méthode checkFileNotEmpty, en lui passant le nom de fichier « test.txt » comme argument. Nous gérons deux types d'exceptions : FileNotFoundException et EmptyFileException.
• La méthode checkFileNotEmpty vérifie si un fichier est vide. Elle prend le nom du fichier en paramètre et peut potentiellement lever deux types d'exceptions : FileNotFoundException et EmptyFileException.
• Dans la méthode checkFileNotEmpty, nous créons un objet File en utilisant le nom de fichier fourni. Nous créons également un objet Scanner pour lire le contenu du fichier.
• Nous utilisons une instruction if pour vérifier si le scanner n'a pas de ligne suivante, ce qui indique que le fichier est vide. Si le fichier est vide, nous lançons une exception EmptyFileException avec le message « File is empty » (le fichier est vide).
• Après avoir vérifié le fichier, nous fermons l'objet Scanner.
• La classe EmptyFileException est une classe d'exception personnalisée qui étend la classe de base Exception. Elle fournit un constructeur qui prend un paramètre de message et le transmet au constructeur de la superclasse à l'aide du mot-clé super.
• Si une exception FileNotFoundException survient dans la méthode principale, elle est capturée et un message d'erreur approprié est affiché.
• Si une exception EmptyFileException se produit dans la méthode checkFileNotEmpty, elle est rattrapée dans la méthode main. Le message d'erreur indiquant que le fichier est vide est affiché.