Avantages des exceptions en langage de programmation de Java

Une exception est un événement, qui se produit pendant l'exécution d'un programme, qui perturbe l'écoulement normal des instructions de programme.

Avantage 1 : Séparation Erreur-Manipulant le code du code "régulier"

Les exceptions fournissent les moyens de séparer les détails de quoi faire quand quelque chose hors de l'ordinaire se produit de "main LOGIC" d'un programme. Dans la programmation traditionnelle, la détection des erreurs, le reportage, et la manipulation mènent souvent au code embrouillant de gaine. Par exemple, considérez la méthode de pseudo-code ici qui lit un dossier entier dans la mémoire :

readFile {
ouvrez le dossier ;
déterminez sa taille ;
assignez que beaucoup de mémoire ;
lisez le dossier dans la mémoire ;
fermez le dossier ;
}

À première vue, cette fonction semble assez simple, mais elle ignore toutes les erreurs potentielles suivantes :

• Que se produit si le dossier ne peut pas être ouvert ?

• Que se produit si la longueur du dossier ne peut pas être déterminée ?

• Que se produit si assez de mémoire ne peut pas être assignée ?

• Que se produit si lu échoue ?

• Que se produit si le dossier ne peut pas être fermé ?

Pour manipuler de tels cas, la fonction readFile doit avoir plus de code pour faire la détection des erreurs, rapportant, et manipulant. Voici un exemple derrière de ce que la fonction pourrait ressembler :

errorCodeType readFile {
initialisez l'errorCode = 0 ;

ouvrez le dossier ;
si (theFileIsOpen) {
déterminez la longueur du dossier ;
si (gotTheFileLength) {
assignez que beaucoup de mémoire ;
si (gotEnoughMemory) {
lisez le dossier dans la mémoire ;
si (readFailed) {
errorCode = -1 ;
}
} autrement {
errorCode = -2 ;
}
} autrement {
errorCode = -3 ;
}
fermez le dossier ;
si (== 0 d'errorCode de && de theFileDidntClose) {
errorCode = -4 ;
} autrement {
errorCode = errorCode et -4 ;
}
} autrement {
errorCode = -5 ;
}
errorCode de retour ;
}

Il y a tellement détection des erreurs, rapportant, et retournant ici que les sept lignes originales du code sont perdues dans l'image de fond. Plus mauvais encore, l'écoulement logique du code a été également perdu, de ce fait le rendant difficile à dire si le code fait la bonne chose : Le dossier est-il vraiment été fermé si la fonction n'assigne pas assez de mémoire ? Il est bien plus difficile de s'assurer que le code continue à faire la bonne chose quand vous modifiez la méthode pendant trois mois après l'écriture il. Beaucoup de programmeurs résolvent ce problème en ignorant simplement des iterrors sont rapportés quand leurs programmes se brisent.

Les exceptions vous permettent d'écrire l'écoulement principal de votre code et de traiter les cas exceptionnels ailleurs. Si la fonction readFile employait des exceptions au lieu des techniques traditionnelles d'erreur-gestion, elle semblerait plus comme ce qui suit :

readFile {
essai {
ouvrez le dossier ;
déterminez sa taille ;
assignez que beaucoup de mémoire ;
lisez le dossier dans la mémoire ;
fermez le dossier ;
} crochet (fileOpenFailed) {
doSomething ;
} crochet (sizeDeterminationFailed) {
doSomething ;
} crochet (memoryAllocationFailed) {
doSomething ;
} crochet (readFailed) {
doSomething ;
} crochet (fileCloseFailed) {
doSomething ;
}
}

Notez que les exceptions ne vous épargnent pas l'effort d'effectuer le travail de détecter, de rapporter, et de manipuler des erreurs, mais elles vous aident à organiser le travail plus efficacement.

Avantage 2 : Propagation des erreurs vers le haut de la pile d'appel

Un deuxième avantage des exceptions est la capacité de propager l'erreur rapportant vers le haut de la pile d'appel de méthodes. Supposez que la méthode readFile est la quatrième méthode dans une série d'appels nichés de méthode faits par le programme principal : method1 appelle method2, qui appelle method3, qui appelle finalement readFile :

method1 {
appel method2 ;
}

method2 {
appel method3 ;
}

method3 {
appel readFile ;
}

Supposez également que method1 est la seule méthode intéressée aux erreurs qui pourraient se produire dans la force traditionnelle method2 et method3 de techniques d'erreur-avis de readFile. pour propager les codes d'erreur retournés par haut readFile la pile d'appel jusqu'à ce que les codes d'erreur atteignent finalement la méthode de method1the seulement qui est intéressée par elles :

method1 {
erreur d'errorCodeType ;
erreur = appel method2 ;
si (erreur)
doErrorProcessing ;
autrement
procédez ;
}

errorCodeType method2 {
erreur d'errorCodeType ;
erreur = appel method3 ;
si (erreur)
erreur de retour ;
autrement
procédez ;
}

errorCodeType method3 {
erreur d'errorCodeType ;
erreur = appel readFile ;
si (erreur)
erreur de retour ;
autrement
procédez ;
}

Rappelez-vous que l'environnement d'exécution de Java recherche vers le début par la pile d'appel pour trouver toutes les méthodes qui sont intéressées à manipuler une exception particulière. Une méthode peut pencher toutes les exceptions jetées dans elle, permettant de ce fait à une méthode plus loin vers le haut de la pile d'appel de l'attraper. Par conséquent, seulement les méthodes qui s'inquiètent des erreurs doivent s'inquiéter de détecter des erreurs :

method1 {
essai {
appel method2 ;
} crochet (exception e) {
doErrorProcessing ;
}
}

method2 jette l'exception {
appel method3 ;
}

method3 jette l'exception {
appel readFile ;
}

Cependant, pendant que le pseudo-code montre, pencher une exception exige un certain effort de la part des méthodes d'intermédiaire. Toutes les exceptions vérifiées qui peuvent être jetées dans une méthode doivent être indiquées dans sa clause de jets.

Avantage 3 : Groupant et différenciant des types d'erreur

Puisque toutes les exceptions jetées dans un programme sont des objets, grouper ou classer des exceptions par catégorie est des résultats normaux de la hiérarchie de classe. Un exemple d'un groupe de classes relatives d'exception dans la plateforme de Java sont ceux définie dans java.ioIOException et ses descendants. IOException est le plus général et représente n'importe quel type d'erreur qui peut se produire en exécutant I/O. Ses descendants représentent des erreurs plus spécifiques. Par exemple, FileNotFoundException signifie qu'un dossier ne pourrait pas être localisé sur le disque.

Une méthode peut écrire les traiteurs spécifiques qui peuvent manipuler une exception très spécifique. La classe de FileNotFoundException n'a aucun descendant, ainsi le traiteur suivant peut manipuler seulement un type d'exception :

crochet (FileNotFoundException e) {
...
}

Une méthode peut attraper une exception basée sur son groupe ou type général en indiquant n'importe lequel superclasses de de la ces exception dans le rapport de crochet. Par exemple, pour attraper toutes les exceptions d'I/O, indépendamment de leur type spécifique, un traiteur d'exception indique un argument d'IOException :

crochet (IOException e) {
...
}

Ce traiteur pourra attraper toutes les exceptions d'I/O, y compris FileNotFoundException, EOFException, et ainsi de suite. Vous pouvez trouver des détails au sujet de ce qui s'est produit en questionnant l'argument passé au traiteur d'exception. Par exemple, employez le suivant pour imprimer la trace de pile :

attrapez (IOException e) {
e.printStackTrace() ; //produit va à System.err.
e.printStackTrace(System.out) ; //envoyez la trace au stdout.
}

Vous pourriez même installer un traiteur d'exception qui manipule n'importe quelle exception avec le traiteur ici :

attrapez (exception e) {traiteur général d'exception// A (trop)
...
}

La classe d'exception est près du dessus de la hiérarchie de classe de THRowable. Par conséquent, ce traiteur attrapera beaucoup d'autres exceptions en plus de ceux que le traiteur est prévu pour attraper. Vous pouvez vouloir manipuler des exceptions de cette façon si tout vous veut que votre programme fasse, par exemple, est la copie hors d'un message d'erreur pour l'utilisateur et puis sort.

Dans la plupart des situations, cependant, vous voulez que les traiteurs d'exception soient aussi spécifiques comme possible. La raison est que la première chose que une nécessité de traiteur est déterminent quel type d'exception s'est produit avant qu'il puisse décider de la meilleure stratégie de rétablissement. En effet, en ne décelant pas des erreurs spécifiques, le traiteur doit adapter à n'importe quelle possibilité. Les traiteurs d'exception qui sont bidon trop général rendent le code plus error-prone en attrapant et la manipulation des exceptions qui n'ont pas été prévus par le programmeur et pour ce qui le traiteur n'a pas été prévu.

Comme remarquable, vous pouvez créer des groupes d'exceptions et manipuler des exceptions d'une mode générale, ou vous pouvez employer le type d'exception spécifique pour différencier des exceptions et pour manipuler des exceptions d'une mode exacte.

Déni : Notre site Web n'est pas responsable de l'information contenue par cet article. Cet article reflète nullement les vues, les avis, les pensées ou la croyance du personnel d'annuaire d'articles.

Notification de traduction : L'article "avantages des exceptions en langage de programmation de Java" a été traduit en utilisant un service de traduction automatisé. Nous faisons des excuses sincèrement pour toutes les erreurs de traduction qui se sont produites. Merci de l'arrangement.

Online: 658 users browsing the articles directory