Il est difficile de rendre un programme parfait et il y aura inévitablement diverses anomalies. Par exemple, il y a un bug dans le programme lui-même, tel que l'imprimante manque de papier lorsque le programme imprime ou que la mémoire est insuffisante. Afin de résoudre ces exceptions, nous devons savoir pourquoi l’exception s’est produite. Pour certaines exceptions courantes, nous pouvons également fournir certains plans d'intervention. La gestion des exceptions en langage C est simplement implémentée via les valeurs de retour des fonctions, mais la signification de la valeur de retour est souvent déterminée par convention. Les programmeurs doivent interroger une grande quantité d’informations avant de pouvoir trouver une vague raison. Les langages orientés objet, tels que C++, Java et Python, disposent souvent de mécanismes de gestion des exceptions plus complexes. Le mécanisme de gestion des exceptions en Java est discuté ici.
Gestion des exceptions Java
Gestion des exceptions
Une grande partie du mécanisme de gestion des exceptions de Java provient du C++. Il permet aux programmeurs d'ignorer les problèmes qui ne peuvent pas être traités temporairement pour poursuivre le développement ultérieur, ou de permettre au programme de gérer les exceptions de manière plus intelligente.
Java utilise des objets spéciaux pour représenter des conditions anormales. Ces objets sont appelés objets d'exception. Lorsqu'une exception se produit, Java lancera un objet représentant la situation actuelle en fonction des paramètres prédéfinis. Le soi-disant lancer est un moyen spécial de retour. Le thread fera une pause et quittera les appels de méthode couche par couche jusqu'à ce qu'il rencontre un gestionnaire d'exceptions. Le gestionnaire d'exceptions peut intercepter l'objet d'exception et décider de l'action suivante en fonction de l'objet, par exemple :
Rappelez à l'utilisateur de gérer les exceptions et continuez le programme pour quitter le programme
...
Le gestionnaire d'exceptions ressemble à ceci, il se compose de try, catch, enfin et des blocs suivants. finalement, ce n'est pas nécessaire.
essayez { ...;}catch() { ...;}catch() { ...;}finalement { ...;}Ce gestionnaire d'exceptions surveille le bloc de programme après l'essai. Les parenthèses catch ont un paramètre qui représente le type d’exception à intercepter. catch capturera le type correspondant et ses classes dérivées. Le bloc de programme après try contient les opérations à effectuer pour le type d'exception. Le bloc de programme surveillé par try peut lever plus d'un type d'exception, de sorte qu'un gestionnaire d'exceptions peut avoir plusieurs modules catch. Le bloc de programme après enfin est un programme qui doit être exécuté indépendamment du fait qu'une exception se produise ou non.
Nous mettons en place des programmes qui peuvent mal tourner et doivent être surveillés, et concevons des solutions pour gérer les exceptions dans les captures.
Ce qui suit est un programme Java partiel qui utilise la gestion des exceptions. La partie try du programme lit les lignes de texte d'un fichier. Pendant le processus de lecture du fichier, une IOException peut se produire :
BufferedReader br = new BufferedReader(new FileReader("file.txt"));try { StringBuilder sb = new StringBuilder(); String line = br.readLine(); ; sb.append("/n"); line = br.readLine( } Chaîne tout = sb.toString();} catch(IOException e) { e.printStackTrace(); System.out.println("Problème IO");}finalement { br.close();}Si nous attrapons l'objet de classe IOException e, nous pouvons opérer sur l'objet. Par exemple, appelez printStackTrace() de l’objet pour imprimer l’état actuel de la pile. De plus, nous avons également imprimé l'invite « Problème IO » sur le milieu de gamme.
Qu'il y ait une exception ou non, le programme finira par entrer dans le bloc final. Nous fermons le fichier dans le bloc enfin et effaçons les ressources occupées par le descripteur de fichier.
type d'exception
Les classes d'exception en Java héritent toutes de la classe Trowable. Un objet de la classe Throwable peut être lancé (lancer).
Orange : décoché ; bleu : coché
Les objets jetables peuvent être divisés en deux groupes. Un groupe est constitué d'exceptions non contrôlées. Les mécanismes de gestion des exceptions ne sont souvent pas utilisés pour ce groupe d'exceptions, notamment :
1. La classe Error fait généralement référence aux erreurs internes de Java et aux erreurs telles que l'épuisement des ressources. Lorsqu'une erreur (et ses dérivés) se produit, nous ne pouvons pas résoudre l'erreur au niveau de la programmation, nous devons donc quitter le programme directement.
2. La classe Exception possède une classe dérivée spéciale RuntimeException. RuntimeException (et ses dérivés) sont provoqués par le programme Java lui-même, c'est-à-dire par des erreurs du programmeur lors de la programmation. RuntimeException peut être complètement évité en modifiant le programme Java. Par exemple, la conversion d'un objet d'un type en un autre type sans relation d'héritage est une ClassCastException. De telles anomalies devraient et peuvent être évitées.
Les autres sont des exceptions vérifiées. Ces classes sont provoquées par des interactions de programmation avec l'environnement qui provoquent des erreurs dans le programme au moment de l'exécution. Par exemple, lors de la lecture d'un fichier, une IOException se produit en raison d'une erreur dans le fichier lui-même. Un autre exemple est que le serveur réseau modifie temporairement le pointage d'URL, provoquant une MalformedURLException. Le système de fichiers et le serveur réseau sont en dehors de l'environnement Java et ne sont pas sous le contrôle du programmeur. Si les programmeurs peuvent anticiper les exceptions, ils peuvent utiliser le mécanisme de gestion des exceptions pour développer des plans de réponse. Par exemple, lorsqu'il y a un problème avec un fichier, l'administrateur système est alerté. Un autre exemple est qu'en cas de problème avec le serveur réseau, l'utilisateur reçoit un rappel et attend la récupération du serveur réseau. Le mécanisme de gestion des exceptions est principalement utilisé pour gérer de telles exceptions.
lancer une exception
Dans le programme ci-dessus, l'exception vient de notre appel à l'API Java IO. Nous pouvons également lancer des exceptions dans nos propres programmes, comme la classe de batterie suivante, qui possède des méthodes de charge et d'utilisation :
public class Test{ public static void main(String[] args) { Batterie aBattery = new Battery(); aBattery.chargeBattery(0.5); aBattery.useBattery(-0.5); / public void chargeBattery(double p) { // puissance <= 1 if (this.power + p < 1.) { this.power = this.power + p; } else { this.power = 1.; } } /** * consommer la batterie */ public boolean useBattery(double p) { try { test(p } catch(Exception e) { System. out.println("catch Exception"); System.out.println(e.getMessage()); p = 0.0; } if (this.power >= p) { this.power = this.power - p; return true; } else { this.power = 0.0; return false; } } /** * utilisation du test */ private void test(double p) throws Exception // Je viens de lancer, ne gère pas { if ( p < 0) { Exception e = new Exception("p doit être positif"); throw e; } } double puissance privée = 0,0 ; // pourcentage de batterie}useBattery() indique l'utilisation du fonctionnement sur batterie. Il existe un paramètre dans la méthode useBattery() qui indique la quantité d’électricité utilisée. Nous utilisons la méthode test() pour tester ce paramètre. Si ce paramètre est négatif, alors nous pensons qu'il y a une exception et la lançons.
En test, lorsqu'une exception se produit (p < 0), nous créons un objet Exception e et utilisons une chaîne comme paramètre. La chaîne contient des informations relatives aux exceptions et ce paramètre n'est pas obligatoire. Utilisez throw pour lancer l’objet Exception.
Nous avons un gestionnaire d'exceptions dans useBattery(). Étant donné que la méthode test() ne gère pas directement l'exception qu'elle génère, mais lève l'exception à la fonction useBattery() supérieure, nous devons expliquer l'exception levée dans la définition de test().
(En supposant que le gestionnaire d'exceptions ne se trouve pas dans useBattery(), mais dans la méthode main() de niveau supérieur, nous devons également ajouter throws Exception à la définition de useBattery().)
Dans catch, nous utilisons la méthode getMessage() pour extraire les informations contenues dans son exception. Les résultats de l'exécution du programme ci-dessus sont les suivants :
catch Exceptionp doit être positif
Dans le gestionnaire d'exceptions, nous intercepterons toute exception de la classe Exception ou de ses dérivés. Cela ne nous aide souvent pas à identifier les problèmes, en particulier lorsqu'un programme peut générer plusieurs exceptions. Nous pouvons fournir une classe plus spécifique à capturer.
Exception personnalisée
Nous pouvons créer de nouvelles classes d'exceptions via l'héritage. Lors de l'héritage, nous devons souvent remplacer le constructeur. Les exceptions ont deux constructeurs, un sans paramètre et un avec un paramètre String. Par exemple:
class BatteryUsageException extends Exception{ public BatteryUsageException() {} public BatteryUsageException(String msg) { super(msg }})Nous pouvons fournir davantage de méthodes et d’informations liées aux exceptions dans les classes dérivées.
Lorsque vous personnalisez des exceptions, faites attention à la classe de base dont vous héritez. Une classe plus spécifique doit contenir plus d'informations sur les exceptions, telles que IOException versus Exception.
Résumer
La gestion des exceptions résout des problèmes, mais elle en crée également. Dans les grands projets, une gestion excessive et détaillée des exceptions provoque souvent un désordre dans le programme. La gestion des exceptions n’est pas simple de par sa conception et doit être utilisée avec prudence.