Créez vos propres classes d'exception en Java

Java fournit plus de 40 catégories d'exceptions que vous pouvez utiliser dans vos programmes. Les créateurs de Java, cependant, ne pouvaient pas prédire toutes les conditions susceptibles de constituer une exception dans vos applications. Par exemple, vous souhaiterez peut-être déclarer une exception lorsque le solde de votre compte est négatif ou lorsqu’une tierce tente d'accéder à votre compte de messagerie.

La plupart des organisations ont des règles spécifiques pour les données exceptionnelles ; Par exemple, un numéro d'employé ne doit pas dépasser trois chiffres, ou un salaire horaire ne doit pas être inférieur au salaire minimum légal. Bien sûr, vous pouvez gérer ces situations d'erreur potentielles avec des instructions if, mais Java vous permet également de créer vos propres classes Exception.

Pour créer votre propre classe Exception, vous devez étendre une sous-classe de Throwable.
Comme vous voulez toujours créer vos propres exceptions pour les erreurs récupérables, vos classes doivent étendre la classe Exception. Vous pouvez étendre toute sous-classe Exception existante, telle que ArithmeticException ou NullPointerException, mais vous souhaitez généralement hériter directement de Exception. Il est classique de terminer chaque nom de sous-classe Exception par Exception.

La classe Exception contient quatre constructeurs comme suit :

•   Exception() - Construit un nouvel objet Exception avec la valeur null comme message de détail.
•   Exception(String message) - Construit un nouvel objet Exception avec le message de détail spécifié.
•   Exception(String message, Throwable cause) - construit un nouvel objet Exception avec le message de détail spécifié et la cause.
•   Exception(Throwable cause) - construit un nouvel objet Exception avec la cause spécifiée et un message détaillé de cause.toString(), qui contient généralement la classe et le message détaillé de cause, ou null si l'argument de la cause est null.

L'exemple suivant montre une classe CompteException. Son constructeur contient une seule instruction qui transmet la description d’une erreur au constructeur parent Exception. Cette chaîne serait récupérée si vous appeliez la méthode getMessage() avec un objet CompteException.

Exemple 1 :

                                class CompteException extends Exception {
                                    public CompteException() {
                                        super("le solde de votre compte est négatif");
                                    }
                                }
                            

L'exemple suivant montre une classe Gestion qui utilise une exception CompteException.
L'en-tête du constructeur Gestion indique qu'il peut déclencher une exception CompteException; si le salaire est négatif, une nouvelle instance non nommée de la classe CompteException est levée.

Exemple 2 :

                                    public class Gestion {
                                        public Gestion(double salaire) throws CompteException {
                                            if (salaire < 0) {
                                                // lever une exception
                                                throw (new CompteException());
                                            }
                                        }
                                    }
                            

Ce qui suit montre une application qui instancie un objet Gestion. Dans cet exemple, un utilisateur est invité à saisir un salaire. Une fois la valeur entrée, une tentative est faite pour construire un objet Gestion dans un bloc try. Si la tentative aboutit, c'est-à-dire si le constructeur de Gestion ne déclenche pas d'exception, le salaire est affiché. Cependant, si le constructeur Gestion lève une exception CompteException, le bloc catch le reçoit et affiche un message.

Exemple 3 :

                                    public class Test {
                                        public static void main(String args[]) throws CompteException {
                                            Scanner clavier = new Scanner(System.in);
                                            System.out.print("Saisir votre salaire horaire : ");
                                            double salaire = clavier.nextDouble();
                                            try {
                                                Gestion cpt = new Gestion(salaire);
                                                System.out.println("le salaire est " + salaire);
                                            } catch (CompteException e) {
                                                System.out.println("Erreur : " + e.getMessage());
                                            }
                                    
                                            // sinon
                                            clavier.close();
                                        }
                                    }
                            

Vous pouvez lancer n'importe quel type d'exception à tout moment, pas seulement des exceptions de votre propre création. Par exemple, dans n'importe quel programme, vous pouvez lancer du code (new RuntimeException ()). Bien sûr, vous ne voudriez le faire que pour une bonne raison, car Java gère pour vous les exceptions RuntimeExceptions en arrêtant le programme. Comme vous ne pouvez pas anticiper toutes les erreurs possibles, la réponse automatique de Java est souvent la meilleure solution.

Vous ne devez pas créer un nombre excessif de types d'exception spéciaux pour vos classes, en particulier si l'environnement de développement Java contient déjà une classe Exception qui interceptera l'erreur. Les types d'exception supplémentaires ajoutent de la complexité aux autres programmeurs qui utilisent vos classes. Toutefois, lorsque cela est approprié, les classes Exception spécialisées constituent un moyen élégant de gérer les situations d'erreur. Elles vous permettent de séparer votre code d'erreur de la séquence d'événements habituelle et non exceptionnelle. Elles permettent de transmettre les erreurs dans la pile et de les suivre ; et elles permettent aux programmeurs qui utilisent vos classes de gérer des situations exceptionnelles de la manière la plus adaptée à leur application.