Exceptions : cochées, décochées et les vôtres

Bonjour! Dans la dernière conférence, nous nous sommes familiarisés avec un aspect du langage Java tel que les exceptions et avons vu des exemples de travail avec elles. Aujourd'hui, nous allons examiner de plus près leur structure et apprendre également à écrire nos propres exceptions :)

Types d'exceptions

Comme nous l’avons dit, il existe de nombreuses classes d’exceptions en Java, près de 400 ! Mais ils sont tous divisés en groupes, il est donc assez facile de s’en souvenir. Voici à quoi cela ressemble : Toutes les exceptions ont une classe ancêtre commune Throwable. Deux grands groupes en proviennent : les exceptions (Exception) et les erreurs (Error). L'erreur est une erreur critique lors de l'exécution du programme associée au fonctionnement de la machine virtuelle Java. Dans la plupart des cas, l'erreur n'a pas besoin d'être traitée, car elle indique de graves failles dans le code. Les erreurs les plus connues : StackOverflowError- surviennent, par exemple, lorsqu'une méthode s'appelle sans fin, et OutOfMemoryError- surviennent lorsqu'il n'y a pas assez de mémoire pour créer de nouveaux objets. Comme vous pouvez le constater, dans ces situations, le plus souvent, il n'y a rien de spécial à traiter - le code est simplement mal écrit et doit être refait. Les exceptions sont en fait des exceptions : une situation exceptionnelle et imprévue qui s'est produite pendant l'exécution du programme. Ce ne sont pas des erreurs aussi graves qu’Erreur, mais elles nécessitent notre attention. Toutes les exceptions sont divisées en 2 types - cochées ( cochées ) et non cochées ( non cochées ). Toutes les exceptions vérifiées proviennent du Exception. Que signifie « vérifiable » ? Nous l'avons partiellement mentionné dans la dernière leçon : "...le compilateur Java connaît les exceptions les plus courantes et sait dans quelles situations elles peuvent se produire." Par exemple, il sait que si un programmeur lit les données d'un fichier dans le code, il peut facilement arriver que le fichier n'existe pas. Et il existe de nombreuses situations de ce type qu'il peut prédire à l'avance. Par conséquent, le compilateur vérifie notre code à l’avance pour détecter d’éventuelles exceptions. S'il les trouve, il ne compilera pas le code tant que nous ne les aurons pas traités ou transmis au sommet. Le deuxième type d’exception est « non vérifié ». Ils viennent de la classe RuntimeException. En quoi diffèrent-ils de ceux testés ? Il semblerait qu'il existe également un certain nombre de classes différentes qui proviennent RuntimeExceptionet décrivent des exceptions d'exécution spécifiques. La différence est que le compilateur ne s’attend pas à ces erreurs. Il semble dire : « Au moment d'écrire le code, je n'ai rien trouvé de suspect, mais quelque chose s'est mal passé pendant qu'il fonctionnait. Apparemment, il y a des erreurs dans le code ! » Et c’est effectivement le cas. Les exceptions non vérifiées sont le plus souvent le résultat d'erreurs de programmation. Et le compilateur n'est clairement pas en mesure de prévoir toutes les situations incorrectes possibles que les gens peuvent créer de leurs propres mains :) Par conséquent, il ne vérifiera pas la gestion de telles exceptions dans notre code. Vous avez déjà rencontré plusieurs exceptions non vérifiées :

• ArithmeticExceptionse produit lorsqu'il est divisé par zéro
• ArrayIndexOutOfBoundsExceptionSe produit lorsque vous essayez d'accéder à une cellule en dehors du tableau.

Théoriquement, bien sûr, les créateurs de Java auraient pu introduire une gestion obligatoire de telles exceptions, mais que deviendrait alors le code ? Pour toute opération de division de nombres, vous devrez écrire un try-catch pour vérifier si vous divisez accidentellement par zéro ? Chaque fois que vous accédez à un tableau, vous devrez écrire un try-catch pour vérifier si vous avez dépassé ces limites. Tout code écrit serait un spaghetti et complètement illisible. Il est logique que cette idée ait été abandonnée. Par conséquent, les exceptions non contrôlées n'ont pas besoin d'être gérées dans des blocs try-catch ou renvoyées vers le haut, bien que cela soit techniquement possible, comme avec Error.

Comment lever votre exception

Bien entendu, les créateurs de Java ne sont pas en mesure de prévoir toutes les situations exceptionnelles pouvant survenir dans les programmes. Il existe trop de programmes dans le monde et ils sont trop différents. Mais ce n'est pas grave, car vous pouvez créer vos propres exceptions si nécessaire. Cela se fait très facilement. Tout ce que vous avez à faire est de créer votre propre classe. Son nom doit se terminer par « Exception ». Le compilateur n'en a pas besoin, mais les programmeurs lisant votre code comprendront immédiatement qu'il s'agit d'une classe d'exception. De plus, vous devez indiquer que la classe provient de la classe Exception. Ceci est déjà nécessaire au compilateur et à son bon fonctionnement. Par exemple, nous avons une classe Dog - Dog. Nous pouvons promener le chien en utilisant le walk(). Mais avant cela, nous devons vérifier si notre animal porte un collier, une laisse et une muselière. Si l'un de ces éléments manque, nous lancerons notre propre exception DogIsNotReadyException. Son code ressemblera à ceci :

public class DogIsNotReadyException extends Exception {

   public DogIsNotReadyException(String message) {
       super(message);
   }
}

Pour indiquer qu'une classe est une exception, vous devez écrire extends Exception après le nom de la classe : cela signifie que « la classe dérive de la classe Exception ». Dans le constructeur, nous appellerons simplement le constructeur de classe Exceptionavec une ligne message- il affichera à l'utilisateur un message du système décrivant l'erreur qui s'est produite. Voici à quoi cela ressemblera dans notre code de classe :

public class Dog {

   String name;
   boolean isCollarPutOn;
   boolean isLeashPutOn;
   boolean isMuzzlePutOn;

   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

   }

   public void putCollar() {

       System.out.println("The collar is on!");
       this.isCollarPutOn = true;
   }

   public void putLeash() {

       System.out.println("The leash is on!");
       this.isLeashPutOn = true;
   }

   public void putMuzzle() {
       System.out.println("The muzzle is on!");
       this.isMuzzlePutOn = true;
   }

   public void walk() throws DogIsNotReadyException {

   System.out.println("Let's go for a walk!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("Hurrah, let's go for a walk!" + name + " I am glad!");
   } else {
       throw new DogIsNotReadyException("Dog " + name + "not ready for a walk! Check your gear!");
   }
 }

}

Maintenant, notre méthode walk()lève une exception DogIsNotReadyException. Cela se fait à l'aide du mot-clé throw. Comme nous l'avons dit plus tôt, une exception est un objet. Par conséquent, dans notre méthode, lorsqu'une situation exceptionnelle se produit - il manque quelque chose sur le chien - nous créons un nouvel objet de classe DogIsNotReadyExceptionet le lançons dans le programme en utilisant le mot throw. walk()Nous ajoutons des lancers à la signature de la méthode DogIsNotReadyException. En d’autres termes, le compilateur est désormais conscient qu’un appel de méthode walk()peut entraîner une exception. Ainsi, lorsque nous appellerons cela quelque part dans le programme, l'exception devra être gérée. Essayons de faire cela dans la méthode main():

public static void main(String[] args) {

   Dog dog = new Dog("Mukhtar");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();//Unhandled exception: DogIsNotReadyException
}

Ne compile pas, exception non gérée ! Enveloppons notre code dans un bloc try-catchpour gérer l'exception :

public static void main(String[] args) {

   Dog dog = new Dog("Mukhtar");
   dog.putCollar();
   dog.putMuzzle();
   try {
       dog.walk();
   } catch (DogIsNotReadyException e) {
       System.out.println(e.getMessage());
       System.out.println("Checking equipment! Is the collar on?" + dog.isCollarPutOn + "\r\n Is the leash on?"
       + dog.isLeashPutOn + "\r\n Are you wearing a muzzle?" + dog.isMuzzlePutOn);
   }
}

Regardons maintenant le résultat de la console :

Ошейник надет! 
Намордник надет! 
Собираемся на прогулку! 
Собака Мухтар не готова к прогулке! Проверьте экипировку! 
Проверяем снаряжение! Ошейник надет? true
Поводок надет? false 
Намордник надет? true

Regardez à quel point la sortie de la console est devenue beaucoup plus informative ! Nous voyons chaque étape qui s'est produite dans le programme ; Nous voyons où l'erreur s'est produite et remarquons immédiatement ce qui manque exactement à notre chien :) C'est ainsi que nous créons nos propres exceptions. Comme vous pouvez le constater, rien de compliqué. Et bien que les développeurs Java n'aient pas pris la peine d'ajouter une exception particulière à leur langage pour les chiens mal équipés, nous avons corrigé leur oubli :)