Exercices Java - Gestion des Exceptions

Exercice 1: Gestion des Exceptions dans un Zoo

Question : Décrire le comportement de chaque cas lorsque la méthode verifierSituation est appelée avec les valeurs 1, 2 et toute autre valeur. Énumérer les messages affichés dans chaque bloc try, catch et finally.

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

        class AnimalEnDangerException extends AnimalAbsentException {
            public AnimalEnDangerException(String message) {
                super(message);
            }
        }

        class Zoo {
            static void verifierSituation(int situation) throws Exception {
                switch (situation) {
                    case 1:
                        System.out.println("Vérification : Animal absent");
                        throw new AnimalAbsentException("L'animal demandé est absent.");
                    case 2:
                        System.out.println("Vérification : Animal en danger");
                        throw new AnimalEnDangerException("L'animal est en danger !");
                    default:
                        System.out.println("Vérification : Problème générique");
                        throw new Exception("Problème générique dans le zoo.");
                }
            }

            public static void main(String[] args) {
                for (int situation = 1; situation <= 3; situation++) {
                    try {
                        verifierSituation(situation);
                    } catch (AnimalEnDangerException e) {
                        System.out.println("Catch AnimalEnDangerException : " + e.getMessage());
                    } catch (AnimalAbsentException e) {
                        System.out.println("Catch AnimalAbsentException : " + e.getMessage());
                    } catch (Exception e) {
                        System.out.println("Catch Exception : " + e.getMessage());
                    } finally {
                        System.out.println("Fin de la vérification de la situation dans le zoo.");
                    }
                }
            }
        }

Exercice 2: Vérification des Nombres

Question : Indiquer ce qui se passe lorsque les nombres saisis comportent des valeurs négatives impaires et/ou lorsque la somme des nombres dépasse 5000. Écrire le message affiché pour chaque situation.

        import java.util.Scanner;

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

        class Number {
            public void verifierNombres(int[] nombres) throws InvalidNumberException {
                int somme = 0;
                for (int n : nombres) {
                    if (n < 0 && n % 2 != 0) {
                        throw new InvalidNumberException("Erreur : Le nombre " + n + " est impair et négatif.");
                    }
                    somme += n;
                }

                if (somme > 5000) {
                    throw new InvalidNumberException("Erreur : La somme des nombres dépasse 5000. Somme = " + somme);
                }
            }
        }

        public class Test {
            public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                int[] nombres = new int[10];
                
                System.out.println("Entrez 10 nombres :");
                for (int i = 0; i < 10; i++) {
                    System.out.print("Nombre " + (i + 1) + ": ");
                    nombres[i] = sc.nextInt(); 
                }

                Number v = new Number();
                
                try {
                    v.verifierNombres(nombres); 
                    System.out.println("Les nombres saisis sont valides.");
                } catch (InvalidNumberException e) {
                    System.out.println(e.getMessage());
                } finally {
                    sc.close();
                    System.out.println("Fin du programme.");
                }
            }
        }

Exercice 3: Vérification des Entiers

Question : Écrire les messages affichés lorsque la valeur saisie est supérieure à 10, inférieure à 5, et entre les deux.

        import java.util.Scanner;

        class CustomException extends Exception {
            public int n;
            public CustomException(int n) { this.n = n; }
        }

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

                System.out.print("Entrez un nombre entier : ");
                n = scanner.nextInt();

                try {
                    if (n > 10) throw new CustomException(n);
                } catch (CustomException e) {
                    System.out.println("Catch 1 - n est supérieur à 10 : n = " + e.n);
                }

                try {
                    if (n < 5) throw new CustomException(n);
                } catch (CustomException e) {
                    System.out.println("Catch 2 - n est inférieur à 5 : n = " + e.n);
                }
                System.out.println("Fin du programme");
                scanner.close();
            }
        }

Exercice 4: Exceptions avec Switch-Case

Question : Décrire le comportement du programme pour les valeurs -1, 1, 0, et un nombre non spécifié.

        import java.util.Scanner;

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

        public class SwitchCaseWithPositiveException {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.print("Entrez un entier : ");
                int n = scanner.nextInt();

                switch (n) {
                    case 0:
                        System.out.println("Le nombre est zéro.");
                        break;
                    case 1:
                        try {
                            verifierPositif(n);
                            System.out.println(n + " est positif.");
                        } catch (PositiveNumberException e) {
                            System.out.println("Exception capturée : " + e.getMessage());
                        }
                        break;
                    case -1:
                        try { verifierPositif(n); }
                        catch (PositiveNumberException e) {
                            System.out.println("Exception capturée : " + e.getMessage());
                        }
                        break;
                    default:
                        try { verifierPositif(n); }
                        catch (PositiveNumberException e) {
                            System.out.println("Exception capturée : " + e.getMessage()); }
                        break;
                }
                scanner.close();
            }

            public static void verifierPositif(int n) throws PositiveNumberException {
                if (n > 0) { throw new PositiveNumberException("Erreur : " + n + " est un nombre positif."); }
            }
        }

Exercice 5: Traitement des Exceptions Personnalisées

Question : Quelles sont les différentes exceptions lancées lorsque la méthode traiterDonnees est appelée avec des données invalides ? Décrivez chaque message d'erreur.

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

        class DonneeVideException extends DonneeInvalideException {
            public DonneeVideException(String message) {
                super(message);
            }
        }

        public class TraitementDonnees {
            public void traiterDonnees(String data) throws DonneeInvalideException {
                if (data == null) {
                    throw new DonneeInvalideException("Erreur : Donnée est nulle.");
                }
                if (data.isEmpty()) {
                    throw new DonneeVideException("Erreur : Donnée est vide.");
                }
                System.out.println("Traitement des données : " + data);
            }

            public static void main(String[] args) {
                TraitementDonnees td = new TraitementDonnees();
                String[] donnees = {null, "", "Donnée valide"};

                for (String data : donnees) {
                    try {
                        td.traiterDonnees(data);
                    } catch (DonneeInvalideException e) {
                        System.out.println(e.getMessage());
                    }
                }
            }
        }

Exercice 6: Gestion des Exceptions avec Input/Output

Question : Quelle est la sortie du programme si le fichier n'existe pas ou si les droits d'accès sont insuffisants ?

        import java.io.*;

        public class FichierTest {
            public static void main(String[] args) {
                try {
                    BufferedReader reader = new BufferedReader(new FileReader("fichier_inexistant.txt"));
                    String line;
                    while ((line = reader.readLine()) != null) {
                        System.out.println(line);
                    }
                    reader.close();
                } catch (FileNotFoundException e) {
                    System.out.println("Exception : Fichier non trouvé.");
                } catch (IOException e) {
                    System.out.println("Exception : Erreur de lecture du fichier.");
                } finally {
                    System.out.println("Fin de l'opération de lecture.");
                }
            }
        }

Exercice 7: Utilisation de Multiple Exceptions

Question : Que se passe-t-il lorsque des exceptions différentes sont lancées dans des blocs try distincts ? Décrire la sortie pour chaque scénario.

        public class MultipleExceptions {
            public static void main(String[] args) {
                try {
                    int a = 10 / 0; // division par zéro
                } catch (ArithmeticException e) {
                    System.out.println("Catch ArithmeticException : " + e.getMessage());
                }

                try {
                    String str = null;
                    str.length(); // NullPointerException
                } catch (NullPointerException e) {
                    System.out.println("Catch NullPointerException : " + e.getMessage());
                }

                System.out.println("Fin du programme.");
            }
        }

Exercice 8: Création d'une Exception Personnalisée

Question : Que se passe-t-il si une entrée non valide est saisie lors de la création d'un objet ? Décrire le message d'erreur affiché.

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

        class Personne {
            private String nom;
            private int age;

            public Personne(String nom, int age) throws AgeInvalideException {
                this.nom = nom;
                if (age < 0) {
                    throw new AgeInvalideException("Erreur : L'âge ne peut pas être négatif.");
                }
                this.age = age;
            }

            public void afficherDetails() {
                System.out.println("Nom : " + nom + ", Age : " + age);
            }
        }

        public class TestPersonne {
            public static void main(String[] args) {
                try {
                    Personne p = new Personne("Alice", -5);
                    p.afficherDetails();
                } catch (AgeInvalideException e) {
                    System.out.println(e.getMessage());
                }
            }
        }

Exercice 9: Exceptions et Boucles

Question : Que se passe-t-il si une exception se produit dans la boucle ? Décrire comment l'exécution est affectée.

        public class BoucleAvecExceptions {
            public static void main(String[] args) {
                for (int i = 0; i < 5; i++) {
                    try {
                        if (i == 3) {
                            throw new Exception("Exception lancée à i = " + i);
                        }
                        System.out.println("i = " + i);
                    } catch (Exception e) {
                        System.out.println("Catch Exception : " + e.getMessage());
                    }
                }
                System.out.println("Fin de la boucle.");
            }
        }

Exercice 10: Exception de Classe Abstraite

Question : Comment la gestion des exceptions fonctionne-t-elle avec des classes abstraites ? Décrire le comportement du programme.

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

        class ExceptionConcrete extends ExceptionAbstraite {
            public ExceptionConcrete(String message) {
                super(message);
            }
        }

        public class TestAbstraite {
            public static void main(String[] args) {
                try {
                    throw new ExceptionConcrete("Erreur avec une exception concrète.");
                } catch (ExceptionAbstraite e) {
                    System.out.println("Catch ExceptionAbstraite : " + e.getMessage());
                }
            }
        }

Exercices de gestion d'exceptions en Java

Exercice 1 : Gestion des situations d'un zoo

Question : Implémentez un programme qui simule plusieurs situations dans un zoo. Les exceptions doivent être levées selon la situation :

Situation 1 : Animal absent
Situation 2 : Animal en danger
Situation 3 : Problème générique

class AnimalAbsentException extends Exception {
    public AnimalAbsentException(String message) { super(message); }
}
class AnimalEnDangerException extends AnimalAbsentException {
    public AnimalEnDangerException(String message) { super(message); }
}
class Zoo {
    static void verifierSituation(int situation) throws Exception {
        switch (situation) {
            case 1:
                System.out.println("Animal absent");
                throw new AnimalAbsentException("L'animal demandé est absent.");
            case 2:
                System.out.println("Animal en danger");
                throw new AnimalEnDangerException("L'animal est en danger !");
            default:
                throw new Exception("Problème générique.");
        }
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            try {
                verifierSituation(i);
            } catch (AnimalEnDangerException | AnimalAbsentException e) {
                System.out.println("Exception : " + e.getMessage());
            } finally {
                System.out.println("Fin de vérification.");
            }
        }
    }
}

Exercice 2 : Vérification des nombres et exceptions personnalisées

Question : Implémentez une classe Number qui vérifie si :

Un nombre est négatif et impair : lever une exception
La somme des nombres dépasse 5000 : lever une exception

class InvalidNumberException extends Exception {
    public InvalidNumberException(String message) { super(message); }
}
class Number {
    public void verifierNombres(int[] nombres) throws InvalidNumberException {
        int somme = 0;
        for (int n : nombres) {
            if (n < 0 && n % 2 != 0) {
                throw new InvalidNumberException("Erreur : " + n + " est impair et négatif.");
            }
            somme += n;
        }
        if (somme > 5000) {
            throw new InvalidNumberException("Erreur : La somme dépasse 5000.");
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] nombres = new int[10];
        System.out.println("Entrez 10 nombres :");
        for (int i = 0; i < 10; i++) {
            nombres[i] = sc.nextInt();
        }
        try {
            new Number().verifierNombres(nombres);
            System.out.println("Les nombres sont valides.");
        } catch (InvalidNumberException e) {
            System.out.println(e.getMessage());
        } finally {
            sc.close();
            System.out.println("Fin du programme.");
        }
    }
}

Exercice 3 : Gestion de flux avec deux blocs `try`

Question : Implémentez un programme avec deux blocs try qui lèvent une exception si :

Le nombre est supérieur à 10
Le nombre est inférieur à 5

class CustomException extends Exception {
    public int n;
    public CustomException(int n) { this.n = n; }
}
public class Chemin {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Entrez un nombre entier : ");
        int n = scanner.nextInt();
        try {
            if (n > 10) throw new CustomException(n);
        } catch (CustomException e) {
            System.out.println("Exception : n = " + e.n);
        }
        try {
            if (n < 5) throw new CustomException(n);
        } catch (CustomException e) {
            System.out.println("Exception : n = " + e.n);
        } finally {
            scanner.close();
            System.out.println("Fin du programme.");
        }
    }
}

Exercice 4 : Vérification d'un entier avec limites

Question : Créez un programme qui vérifie si un entier saisi est dans l'intervalle [0, 100]. Si le nombre est en dehors des limites, levez une exception personnalisée.

class IntegerException extends Exception {
    public IntegerException(String message) { super(message); }
}
public class IntegerExceptionHandling {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Entrez un entier : ");
        int n = scanner.nextInt();
        try {
            if (n < 0 || n > 100) throw new IntegerException("Hors limites : " + n);
            System.out.println(n + " est dans l'intervalle.");
        } catch (IntegerException e) {
            System.out.println(e.getMessage());
        } finally {
            scanner.close();
        }
    }
}

Exercice 5 : Gestion de chaînes et exceptions

Question : Implémentez un programme qui utilise un String et un StringBuffer pour gérer différentes situations selon le nombre entré. Gérer les cas avec des exceptions personnalisées.

class NegativeNumberException extends Exception {
    public NegativeNumberException(String message) { super(message); }
}
public class StringAndExceptionHandling {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Entrez un entier : ");
        int n = scanner.nextInt();
        String str = "Valeur initiale";
        StringBuffer stringBuffer = new StringBuffer("Buffer initial");
        try {
            if (n == 0) throw new NegativeNumberException("Nombre négatif interdit.");
            if (n == 1) stringBuffer.append(" - Ajout");
            if (n == 2) stringBuffer.replace(0, 6, "Modif");
        } catch (NegativeNumberException e) {
            System.out.println(e.getMessage());
        } finally {
            System.out.println("Valeur finale : " + stringBuffer);
            scanner.close();
        }
    }
}

RAPPELS

Qu'est-ce qu'une Exception ?

Une exception en Java est un événement qui se produit lors de l'exécution d'un programme, perturbant son flux normal. Les exceptions peuvent être causées par divers facteurs, comme des erreurs de logique, des entrées invalides ou des problèmes d'exécution (par exemple, tentative de division par zéro).

Types d'Exceptions

Exceptions vérifiées (Checked Exceptions) : Ce sont des exceptions que le compilateur vérifie à la compilation. Elles doivent être déclarées dans la méthode en utilisant `throws` ou gérées avec un bloc `try-catch`. Exemple : IOException, SQLException.
Exceptions non vérifiées (Unchecked Exceptions) : Ce sont des exceptions qui ne sont pas vérifiées à la compilation. Elles héritent de RuntimeException. Exemple : NullPointerException, ArithmeticException.
Erreurs (Errors) : Ce sont des problèmes graves qui ne peuvent généralement pas être gérés par l'application. Exemple : OutOfMemoryError, StackOverflowError.

Gestion des Exceptions

La gestion des exceptions se fait généralement à l'aide des blocs try, catch, finally et throw.

try

Le bloc try contient le code qui pourrait générer une exception. Si une exception se produit, le flux de contrôle passe au bloc catch correspondant.

catch

Le bloc catch permet de gérer l'exception qui a été levée dans le bloc try. Il peut capturer l'exception et exécuter le code de traitement approprié.

finally

Le bloc finally est toujours exécuté après le bloc try et les blocs catch, qu'une exception soit levée ou non. Il est souvent utilisé pour libérer des ressources (comme fermer des fichiers).

throw

Le mot-clé throw est utilisé pour lancer explicitement une exception dans le code. Cela peut être une exception personnalisée ou une exception existante.

throw new NullPointerException("Un message d'erreur ici");

throws

Le mot-clé throws est utilisé dans la déclaration d'une méthode pour indiquer que cette méthode peut lancer une ou plusieurs exceptions vérifiées. Cela informe l'appelant de la méthode qu'il doit gérer ces exceptions.

public void maMethode() throws IOException {
    // Code qui peut lancer IOException
}

Exemples d'Exceptions de Base

ArithmeticException : Lancée lors d'une opération arithmétique illégale, comme la division par zéro.
NullPointerException : Lancée lorsqu'une opération est effectuée sur une référence null.
ArrayIndexOutOfBoundsException : Lancée lorsque l'application tente d'accéder à un index en dehors des limites d'un tableau.
ClassNotFoundException : Lancée lorsqu'une application tente de charger une classe par son nom mais ne parvient pas à la trouver.
IOException : Lancée lorsqu'une opération d'entrée/sortie échoue ou est interrompue.

Si vous avez trouvé les exercices corrigés en Java de Mr JoëlYk intéressants et utiles, pourquoi ne pas les partager avec d'autres personnes qui pourraient également en bénéficier ? Partagez ce lien sur les réseaux sociaux ou envoyez-le à vos amis et collègues. Vous pourriez aider quelqu'un à améliorer ses compétences en programmation ou à trouver des solutions à des problèmes complexes. N'oubliez pas que la connaissance doit être partagée pour grandir. Merci pour votre soutien et votre partage !

Contact WhatsApp : +237 652027193 | Réaliser Par Joël_Yk