Gestion des exceptions Java-javaDidacticiel-php.cn

Java Exception Handling

Les bases

Comprendre les exceptions : que se passe-t-il lorsque les choses tournent mal ?

Imaginez que vous jouez à un jeu et que tout à coup, votre personnage tombe dans un gouffre. Que feriez-vous? Vous redémarreriez probablement le jeu ou trouveriez un moyen d’éviter la fosse la prochaine fois. En programmation, quelque chose de similaire peut se produire : votre code peut tomber dans un « gouffre » appelé exception. Lorsque cela se produit, le programme peut cesser de fonctionner ou faire quelque chose d'inattendu.

Qu'est-ce qu'une exception exactement ?

Une exception est comme un signal indiquant que quelque chose s'est mal passé pendant l'exécution de votre code. Peut-être avez-vous essayé de diviser un nombre par zéro (ce qui n’est pas autorisé), ou peut-être avez-vous essayé d’ouvrir un fichier qui n’existe pas. Lorsque ces problèmes apparaissent, Java lève un drapeau et dit : "Hé ! Il y a un problème ici !"

Que se passe-t-il sans gestion des exceptions ?

Si nous ne gérons pas les exceptions, le programme peut planter et toute la progression est perdue, tout comme lorsque vous ne sauvegardez pas votre partie et que l'ordinateur s'éteint soudainement.

Voyons un exemple :

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;
        int result = number / 0; // This will cause an exception!
        System.out.println("Result: " + result); // This line will never be reached.
    }
}

Copier après la connexion

Lorsque vous essayez d'exécuter ce code, il s'arrêtera et se plaindra en disant : "Vous ne pouvez pas diviser par zéro !"

Comment pouvons-nous éviter la fosse ?

Pour éviter ce problème, Java nous propose quelque chose appelé try and catch.

essayez Bloquer : C'est ici que vous essayez de faire quelque chose qui pourrait causer un problème.
catch Block : C'est ici que vous détectez le problème s'il se produit, afin que votre programme ne plante pas.

Réécrivons notre exemple :

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;

        try {
            int result = number / 0; // We know this might cause a problem.
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

Copier après la connexion

Voici ce qui se passe maintenant :

Le bloc try essaie de diviser par zéro.
Lorsque Java voit le problème, il passe au bloc catch et dit : "Oups ! Vous ne pouvez pas diviser par zéro."

Attraper différents problèmes

En savoir plus sur la détection des exceptions

Maintenant que vous savez comment intercepter une exception, vous vous demandez peut-être : « Et si mon code pouvait rencontrer différents types de problèmes ? Comment puis-je tous les intercepter ? »

Imaginez que vous essayez d'ouvrir un coffre au trésor dans un jeu. Parfois, la clé ne rentre pas (c’est un problème), et d’autres fois, le coffre est vide (c’est un autre problème). Vous voudriez savoir exactement ce qui n’a pas fonctionné, n’est-ce pas ?

Différents types d'exceptions

En Java, il existe différents types de problèmes, ou exceptions. Par exemple :

ArithmeticException : Lorsque vous essayez de faire des mathématiques, cela n'a pas de sens, comme diviser par zéro.
NullPointerException : lorsque vous essayez d'utiliser quelque chose qui n'existe pas encore (comme essayer d'ouvrir un coffre au trésor qui n'existe pas).
ArrayIndexOutOfBoundsException : lorsque vous essayez d'accéder à un tableau pour quelque chose qui dépasse ses limites, comme demander le 11ème cookie dans un pot qui n'en contient que 10.

Détecter plusieurs exceptions

Voyons comment détecter différents types de problèmes dans votre code :

public class MultipleExceptionsExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // This will cause an ArrayIndexOutOfBoundsException!
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Oops! You tried to access an index that doesn’t exist.");
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

Copier après la connexion

Voici ce qui se passe :

Le code du bloc try essaie de faire quelque chose qui pourrait causer un problème.
S'il rencontre une exception ArrayIndexOutOfBoundsException, il passe au premier bloc catch.
S'il rencontre une ArithmeticException, il passe au deuxième bloc catch.

Et si je veux détecter un problème ?

Parfois, vous ne savez peut-être pas ce qui pourrait mal se passer, mais vous voulez quand même détecter tout problème. Vous pouvez utiliser une exception générale pour détecter tout ce qui ne va pas :

public class GeneralExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an ArithmeticException!
        } catch (Exception e) {
            System.out.println("Oops! Something went wrong.");
        }
    }
}

Copier après la connexion

De cette façon, si quelque chose ne va pas, le bloc catch le gérera toujours et votre programme ne plantera pas.

Nettoyer et créer des exceptions personnalisées

Le bloc enfin

Imaginez que vous jouez à un jeu et que vous trouvez un trésor, mais que vous réussissiez ou non, vous voulez toujours fermer le coffre au trésor lorsque vous avez terminé. En Java, le bloc final revient à s'assurer que le coffre au trésor est toujours fermé, quoi qu'il arrive.

Qu'est-ce que le bloc final ?

Le bloc final est un morceau de code qui s'exécute toujours, qu'une exception se produise ou non. Il est utilisé pour faire le ménage, comme fermer un dossier, arrêter un minuteur ou ranger le coffre au trésor.

Voyons un exemple :

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an exception.
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        } finally {
            System.out.println("This will always run, no matter what.");
        }
    }
}

Copier après la connexion

Voici ce qui se passe :

The try block tries to do something risky.
The catch block catches the problem if it happens.
The finally block always runs, even if there’s no problem.

Making Your Own Custom Exceptions

Sometimes, the problems you face in your code are special. Maybe the game doesn’t just have treasure chests, but also magical doors that can sometimes be locked. You might want to create a special exception for when the door is locked.

Creating a Custom Exception

You can create your own exceptions by making a new class that extends Exception. Let’s create an exception called LockedDoorException:

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

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            openDoor(false);
        } catch (LockedDoorException e) {
            System.out.println(e.getMessage());
        }
    }

    private static void openDoor(boolean hasKey) throws LockedDoorException {
        if (!hasKey) {
            throw new LockedDoorException("The door is locked! You need a key.");
        }
        System.out.println("The door is open!");
    }
}

Copier après la connexion

Here’s how it works:

We create a new exception called LockedDoorException.
When we try to open the door without a key, we throw the LockedDoorException.
The catch block catches our custom exception and tells us what went wrong.

Summary

In this post, we’ve learned that:

Exceptions are problems that happen when your code is running.
try and catch blocks help us handle these problems, so our program doesn’t crash.
Different types of exceptions are like different kinds of problems.
We can catch multiple exceptions to handle specific problems.
We can also catch any exception using the general Exception type.
The finally block is used to clean up, and it always runs no matter what.
You can create custom exceptions to handle special problems in your code.