Exceptions en Java

Lorsque je suis tombé sur le sujet « Exceptions », de nombreuses questions se sont posées auxquelles j'ai dû chercher des réponses dans différents coins d'Internet afin de comprendre en détail comment tout cela fonctionne. En conséquence, j'ai compilé ma propre explication, qui sera peut-être plus compréhensible pour les débutants qui viennent de rencontrer ce phénomène. Dans les ordinateurs, une interruption est un signal entrant au processeur indiquant qu'un événement se produit et nécessite une réponse immédiate. Un signal d'interruption nécessite que le processeur mette en pause un programme en cours d'exécution afin de pouvoir le poursuivre un peu plus tard, c'est-à-dire que l'ordinateur doit mémoriser toutes les informations associées à l'exécution du programme. De telles interruptions sont temporaires, voire fatales. De telles interruptions peuvent être causées soit par le code du programme, soit par certaines fonctionnalités matérielles (par exemple, une simple pression sur les touches du clavier ; des minuteries, par exemple, pour éteindre automatiquement l'ordinateur). Le nombre d' interruptions est limité à un certain nombre, intégré à la production d'un processeur particulier, c'est-à-dire que des « canaux » de communication spéciaux sont alloués à cet effet, vous permettant d'accéder au processeur en contournant tous les autres processus. Des interruptions sont également automatiquement générées lorsqu'une erreur se produit dans le code du programme en cours d'exécution (par exemple, si une division par zéro se produit). De telles interruptions sont traditionnellement appelées pièges ou exceptions . Dans de tels cas, il est d'usage de dire : « Une exception a été levée », c'est-à-dire qu'une exception a été déclenchée ou qu'une exception a été lancée (lancée), c'est-à-dire une demande d'interruption.avec la question « que faire ? » envoyé au processeur. A ce moment, le processeur cesse de fonctionner, se souvenant du point où il s'est arrêté, ou plutôt du cluster de la cellule suivante, à partir duquel les informations doivent être exécutées. La chaîne entière des instructions exécutées et NON exécutées est mémorisée. Après quoi, le processeur lit les instructions de la mémoire pour agir en cas d'une telle erreur. Conformément à cette instruction, il peut saisir de nouvelles valeurs dans certains clusters, ajouter des chaînes d'actions ou un nouveau cycle (par exemple, un cycle de retour ou de boucle), etc., c'est-à-dire, en fonction de l'erreur précédemment posée. les instructions vers le bas sont exécutées. Le système informatique lui-même intègre de nombreuses interruptions automatiques, qui sont déclenchées après un certain temps, par exemple pour contrôler les processus en cours d'exécution sur l'ordinateur ou exécuter des alarmes définies, collecter des signaux externes entrants et divers convertisseurs de données. Il convient de rappeler qu'un grand nombre d'interruptions, pour un certain nombre de raisons, peuvent complètement « bloquer » le système. Une erreur dans le code du programme provoquera automatiquement une interruption du processeur, qu'il tentera de traiter conformément aux instructions établies. Mais toutes les interruptions ne sont pas conçues pour les gérer, ou cela peut produire une procédure qui ne nous convient pas, par exemple, cela fera simplement planter l'application. Par conséquent, en programmation, il est possible d'organiser votre propre interruption pour une certaine section de code dans laquelle le programmeur voit potentiellement la possibilité d'une erreur. Dans ce cas, l'erreur sera traitée au sein du programme et ne contactera pas le processeur pour obtenir des instructions de traitement. La définition de tels blocs est organisée en créant un Objet « Exception » . Cet objet est automatiquement créé dans le bloc try-catch. Le bloc >tryest vérifié pour la présence d'une erreur et, s'il y en a une, le programme va au bloc catch, où des actions sont prises pour empêcher ou niveler l'erreur. Par exemple, si nous saisissons des nombres au clavier , qu'il faut ensuite ajouter et soustraire, alors saisir des lettres au clavier rendra impossible leur addition avec des nombres (notons la somme de ces deux variables par la lettre S). Par conséquent, en équipe, trynous devons vérifier si le nombre A, contenant des nombres, peut être ajouté au nombre B, contenant des lettres (c'est-à-dire S = A + B), et si cela n'est pas possible, et c'est impossible, alors certains des mesures doivent être prises pour que les erreurs ne se produisent PAS et qu'une nouvelle interruption avec la question « que faire ? » ne parvienne pas au processeur. S'il n'y a pas d'Exception dans le programme, son exécution sera interrompue par le processeur. S'il y a une exception, lorsqu'elle est « attrapée » par la commande try, le contrôle passe à la commande catch, qui peut définir une solution alternative, par exemple, nous n'ajouterons pas ces deux nombres, mais définirons S = A.

int a = 4;
String b = “hello”;
int S = 0;
 try {
   S = a + b;
   int r = 1;
 } catch (Exception igogo1) {
   S = a;
 }
 return S;

/* chaîne "int r = 1;" n'est pas exécuté car une erreur s'est produite et le programme redirige le travail directement vers le gestionnaire d'exceptions (bloc catch*/ Ainsi, la présence d'exceptions est une opportunité de résoudre le problème au sein du programme sans le lancer au niveau du processeur. L'objet « Exception », qui est automatiquement créé dans le bloc trylorsqu'une erreur est détectée, contient la valeur du type d'erreur. Appelons-le « OurException » - pour notre cas spécifique avec une description de notre erreur spécifique. Les créateurs du langage Java ont créé à l'avance une certaine liste d'erreurs typiques et d'options typiques pour les corriger, c'est-à-dire qu'en Java, il existe une certaine bibliothèque d'exceptions vers laquelle nous pouvons nous tourner pour gérer une erreur qui s'est produite, afin que ne pas écrire le code de traitement nous-mêmes et donc OurException est très probablement déjà décrit par quelqu'un, nous avons donc juste besoin de connaître le nom de laquelle de ces exceptions insérer dans notre programme pour gérer le code là où une panne pourrait potentiellement se produire. Si nous faisons une erreur et sélectionnons une exception incorrecte dans la bibliothèque , alors le gestionnaire ne la « détectera » pas, l'erreur ne trouvera pas de solution dans le programme et la demande sera envoyée au processeur. Mais il existe un moyen pour les paresseux. Si nous ne connaissons pas le nom de l'exception dont nous avons besoin dans la bibliothèque, nous pouvons alors prendre l'exception générale avec le nom « Exception », comme dans l'exemple décrit ci-dessus. Cette exception est capable de gérer tout type d'erreur, mais elle n'est pas capable de fournir des informations spécifiques sur l'incident que nous pourrions enregistrer. La bibliothèque d' exceptions précédemment écrites se compose d' exceptions cochées et non cochées . Les vérifiables sont ceux qui peuvent être corrigés sans interrompre le travail du programme, c'est-à-dire que si nous essayons d'ouvrir un fichier dans un dossier dans lequel il n'existe pas, le système nous le fera savoir, nous pourrons supprimer le fichier. dans le dossier souhaité et continuez le programme. Autrement dit, une demande d' interruption a été envoyée au processeur , mais sans la question : "cherchez quoi faire à propos de ce problème ?!?!" Nous avons envoyé une interruption, que nous avons nous-mêmes détectée, avec une instruction prête à l'emploi, que le processeur a traitée et a continué à exécuter le programme. Les erreurs qui ne peuvent pas être corrigées ne sont pas cochées et le programme sera fermé avant la fin, c'est-à-dire qu'une demande d'interruption sera envoyée au processeur., ce qui interrompra dans tous les cas l'exécution du programme. Le seul intérêt d'écrire de telles exceptions dans le programme est de faire comprendre à l'utilisateur ce qui s'est passé, car, après avoir détecté cette interruption, nous pouvons afficher sur l'écran un message d'information à cause duquel le programme s'est écrasé. La deuxième raison de détecter de telles interruptions est la possibilité de les enregistrer dans les journaux pour une analyse ultérieure (vous avez été piraté, mais au moins vous savez où). Une conséquence de la présence de telles bibliothèques est la nécessité de ne pas oublier de les inclure. (Une liste des exceptions cochées et non cochées avec les bibliothèques peut être trouvée, par exemple, ici ) Si nous ne savons pas exactement quelle bibliothèque inclure ou s'il existe plusieurs options d'erreur, nous pouvons alors catchrépertorier les exceptions requises en plusieurs. Le système lui-même sélectionnera le bon gestionnaire s'il figure dans la liste. Au lieu d'une exception spécifique, vous pouvez écrire une « exception » générale qui peut gérer tout type d'exception si elle n'a pas été traitée dans les blocs précédents.

int a = 4;
String b = “hello”;
int S = 0;
 try {
   S = a + b;
   int r = 1;
 }
catch(NullPointerException blabla2) {
   System.out.println("Exception handling code for the NullPointerException.");
 }
catch (ArithmeticException ex1) {
   S = a;
 }
catch(Exception uups1) {
   System.out.println("Exception occured");
 }
 return S;

S'il y a un blocage, tryune Exception est créée automatiquement. Si nous devons forcer une exception à un moment donné , alors la commande est utilisée throw. C'est-à-dire que nous créons indépendamment un objet new throw... après quoi le programme arrête son travail, envoie une demande d'interruption au processeur et est transféré vers la section du programme catch, d'où il essaie d'obtenir des instructions pour d'autres actions. En créant manuellement une Exception , nous pouvons spécifier son type spécifique depuis la bibliothèque :

throw new ArithmeticException("Access denied - You must be at least 18 years old.");

alors le gestionnaire recherchera un bloc catchavec cette exception particulière - recherchera dans tout le programme, de tous les côtés catch. Après la throwcommande de gestion des exceptions, tout le code de programme restant ne sera PAS exécuté, à l'exception de celui qui se trouve dans le bloc catch. Si le gestionnaire n'est pas trouvé dans le programme, la question est posée au processeur : « décidez vous-même quoi faire » et il interrompt le programme. L'appel new throw... peut être effectué aussi bien à l'intérieur >tryqu'à l'extérieur du bloc (n'importe où dans le programme)

try {
   /* функция or действие, в котором есть сомнения. То есть: «попробуй выполнить это, а если не получится, а, если не получится, запускай режим исключения» */
   throw new CallForException(); /* Назначаем исключение, которое будет работать в случае наличия ошибки в функции, описанной выше. Здесь исключение «CallForException» - берется из библиотеки существующих исключений */
} catch (CallForException ee1) {
   /* Корректируем ошибку, чтобы программа не «отвалилась» or выводим сообщение об ошибке or что-то ещё */
} finally {
   /* этот блок работает всегда независимо от того была ошибка or нет. А если была, то сработало ли решение в catch or нет */
   /* часто используется для подчистки хвостов, например, для закрытия запущенного file or базы данных */
   /* в ряде случаев блок catch вообще может быть опущен и оставлен только блок finally и наоборот finally может быть опущен и оставлен только catch */
   /* Не допускается использование этого блока в ряде случаев, например, когда функция System.exit() запущена or другие системные Исключения, типа «отключение электроэнергии» и т.п. */
}

Notification des exceptions

Les méthodes précédemment écrites par quelqu'un peuvent inclure la levée d'exceptions. Juste par mesure de sécurité, le programmeur qui a écrit le code a averti les programmeurs suivants qu'une erreur pourrait se produire dans la méthode qu'il a écrite. Ainsi, par exemple, la méthode de création de fichier décrite ci-dessous stipule que lors de la création d'un fichier, une erreur peut survenir (il n'y a pas de fichier au chemin indiqué), ce qui signifie qu'un gestionnaire d'erreurs sera nécessaire :

public void createFile(String path, String text) throws IOException {
    FileWriter writer = new FileWriter(path, true);
    writer.write(text);
    writer.close();
}

Mais en même temps, il n'y a pas de gestionnaire lui-même, ce qui signifie que nous ne pourrons désormais plus simplement appeler la méthode écrite dans notre programme en mode normal. Il faut maintenant écrire un gestionnaire d'erreurs et appeler cette méthode dans le bloc try:

String filePath = "hello.txt";
String text = "Hello World";

try {
    createFile(filePath, text);
} catch (IOException ex) {
    System.err.println("Error creating file: " + ex);
}

Exceptions natives

Il est possible d'écrire vos propres exceptions pour gérer certaines erreurs si les bibliothèques existantes ne nous suffisent pas. Pour ce faire, nous créons simplement une classe qui hérite de la classe Exception

public class StudentNotFoundException extends Exception {

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

Il y a deux règles à garder à l’esprit lors de la création de vos propres exceptions :

1. Notre nom de classe doit se terminer par "Exception"
2. La classe doit contenir un constructeur avec une variable chaîne décrivant les détails du problème d'exception. Dans le constructeur, le super constructeur est appelé et un message est passé.

Un exemple d'utilisation de l'exception générée :

public class StudentManager {
    public Student find(String studentID) throws StudentNotFoundException {
        if (studentID.equals("123456")) {
            return new Student();
        } else {
            throw new StudentNotFoundException(
                "Could not find student with ID " + studentID);
        }
    }
}

Nous attrapons cette exception avec le code :

public class StudentTest {
    public static void main(String[] args) {
        StudentManager manager = new StudentManager();
         try {
            Student student = manager.find("0000001");
        } catch (StudentNotFoundException ex) {
            System.err.print(ex);
        }
    }
}

Le résultat de l'exécution du programme sera : StudentNotFoundException : Impossible de trouver l'étudiant avec l'ID 0000001.

Pourquoi devez-vous écrire des exceptions ?

En 1996, la fusée Ariane 5 s'est écrasée à cause d'une conversion incorrecte d'une variable flottante en variable entière. Il n’y avait aucune exception ni gestionnaire pour cette situation. Si lors du téléchargement d'un fichier il y a une perte de connexion à Internet, alors la présence d'une Exception vous permettra de continuer le téléchargement une fois la connexion rétablie. S'il n'y a pas d'exception, le téléchargement devra recommencer.

Les références:

• Interruption dans le matériel
• Exceptions wiki
• Exceptions sur le wiki Java
• Exception dans le wiki (lancer-cacher)
• Type de signature
• Exceptions cochées-non cochées
• urvanov.ru
• Exceptions pour les débutants sur WikiBook
• bloc try-catch
• Créer vos propres exceptions