La vérification des exceptions est l'une des choses les plus importantes dans la programmation et les tests de logiciels. L'exception cochée et non cochée arrête l'exécution du programme lorsqu'il tente de détecter un bogue ou une erreur.
De plus, il est considéré qu'il est de la responsabilité du programmeur de s'assurer que ces erreurs ne se produisent jamais. Les exceptions cochées et non cochées sont exceptionnellement similaires, mais elles sont différentes.
Faits marquants
- Le compilateur vérifie les exceptions vérifiées au moment de la compilation et doit être gérée par le programmeur à l'aide du bloc try-catch ou du mot-clé throws, tandis que les exceptions non vérifiées se produisent au moment de l'exécution et n'ont pas besoin d'être gérées.
- Les exceptions cochées sont utilisées pour les erreurs récupérables, telles que le fichier introuvable, tandis que les exceptions non cochées sont utilisées pour les erreurs irrécupérables, telles que les exceptions de mémoire insuffisante ou de pointeur nul.
- Les exceptions vérifiées font partie de la signature de la méthode, contrairement aux exceptions non vérifiées.
Exception cochée vs non cochée
La différence entre les exceptions vérifiées et non vérifiées est que les exceptions vérifiées sont celles qui doivent être interceptées et gérées par l'instruction checks (), sinon elles entraîneront l'arrêt d'un programme et l'impression d'une trace de pile, alors que les exceptions non vérifiées, d'autre part, devraient pas besoin d'être attrapé ou manipulé du tout, car c'est le programmeurresponsabilité de s'assurer que ces erreurs ne se produisent jamais.
L'exception Checked est un type spécifique d'exception qui arrête l'exécution du programme jusqu'à ce qu'il soit intercepté par un bloc catch ou spécifié dans la clause throws d'une méthode. De plus, l'exception Checked est interceptée et gérée par l'instruction checks (), ou ils provoqueront l'arrêt d'un programme et l'impression d'une trace de pile.
Si le code à l'origine de l'exception n'a pas été testé correctement, cela pourrait provoquer d'étranges bogues exceptionnels non vérifiés qui peuvent être difficiles à trouver et à corriger.
De plus, les exceptions non contrôlées ne doivent pas du tout être interceptées ou gérées, car il est de la responsabilité du programmeur de s'assurer que ces erreurs ne se produisent jamais.
Tableau de comparaison
| Paramètres de comparaison | Exception cochée | Exception non cochée |
|---|---|---|
| Définition | Les exceptions vérifiées sont celles qui doivent être interceptées et gérées par les instructions check(). | Les exceptions non contrôlées ne doivent pas du tout être interceptées ou gérées. |
| Apparition | Un bloc catch doit gérer les exceptions vérifiées au moment de la compilation. | Les exceptions non interceptées, également appelées exceptions d'exécution, sont des exceptions non contrôlées. |
| La gestion des erreurs | Une exception cochée arrête l'exécution du programme jusqu'à ce qu'il tente de détecter un bogue ou une erreur. | Il est de la responsabilité du programmeur de s'assurer que ces erreurs ne se produisent jamais. |
| Classes d'exception | Il a des classes exceptionnelles. | Il n'a pas de classes exceptionnelles, ou il ne fait pas partie des classes exceptionnelles. |
| Exemple | OutOfMemoryError, NullPointerException et StackOverflowError. | IndexOutOfBoundsExceptionIndexOutOfBoundsException |
Qu'est-ce que l'exception vérifiée ?
Les exceptions vérifiées sont étroitement liées aux tests de logiciels. De plus, une exception vérifiée est une exception qui doit être gérée, sinon le programme se terminera.
Cela signifie que le code suivant une instruction throw ne s'exécutera pas si aucun bloc catch ne gère l'exception.
Les exceptions vérifiées ont deux objectifs : elles empêchent le programme de continuer lorsqu'une erreur s'est produite et fournissent des informations de débogage sur l'endroit où trouver cette erreur.
Le compilateur ne force pas le programmeur à gérer l'exception, mais toute classe qui étend une autre classe doit également étendre ou implémenter toutes ses exceptions vérifiées.
Si ce n'est pas le cas, une compilation de la classe d'extension échoue avec une erreur de compilation indiquant qu'elle doit gérer toutes ses exceptions vérifiées par la superclasse. Cela empêche l'héritage d'être utilisé pour contourner les échec modes.
Lorsqu'une exception est levée, elle est transmise au débogueur dans Eclipse ou au système d'exploitation, qui termine alors le programme normalement. Le système d'exploitation imprime une trace de pile.
Une trace de pile fournit des informations pour chaque appel de méthode dans l'ordre dans lequel elles ont été appelées. Cela permet au programmeur de trouver où dans le code ou où dans le flux d'exécution de son code une exception s'est produite.
Qu'est-ce qu'une exception non vérifiée ?
Des exceptions non contrôlées existent pour permettre aux programmeurs de programmer de manière plus flexible et efficace. Java a été conçu pour permettre aux programmeurs de créer des applications qui utilisent efficacement les ressources et évitent l'apparition d'un blocage.
Les exceptions non vérifiées peuvent être éliminées par des pratiques de conception et de codage soignées. Cependant, toutes les exceptions sauf NullPointerException dans le code Java sont considérées comme non contrôlées.
Les exceptions non contrôlées ne doivent pas du tout être interceptées ou gérées.
De plus, ils sont un moyen pour le code de niveau supérieur de dire au code de niveau inférieur qu'il va faire quelque chose qui n'est pas thread-safe mais qui ne causera pas de problèmes s'il n'y a qu'un seul thread en cours d'exécution à un moment donné, comme mettre à jour certaines données ou afficher certains graphiques à l'écran.
L'utilisation d'exceptions non contrôlées est une proposition risquée. Si une classe va lever une exception non vérifiée, alors quiconque utilise cette classe doit en être conscient et avoir des méthodes rigoureuses en place pour la traiter.
Par exemple, un programmeur peut souhaiter lire certaines données d'un fichier, puis les réécrire, et ce type de fonctionnalité ne nécessite aucune synchronisation.
Il est parfaitement acceptable qu'une application lise deux fois les mêmes données sur deux threads différents sans avoir d'effets négatifs sur les performances ou la stabilité du système.
Principales différences entre les exceptions cochées et non cochées
- Les exceptions vérifiées sont celles qui doivent être interceptées et gérées par les instructions checks (), tandis que les exceptions non contrôlées ne doivent pas du tout être interceptées ou gérées.
- Les exceptions vérifiées doivent être gérées par un bloc catch pendant la compilation, tandis que les exceptions non capturées, également appelées exceptions d'exécution, sont des exceptions non vérifiées.
- L'exception cochée arrête le programme de s'exécuter jusqu'à ce qu'il tente de détecter un bogue ou une erreur, tandis que les exceptions non cochées relèvent de la responsabilité du programmeur pour s'assurer que ces erreurs ne se produisent jamais.
- L'exception vérifiée a des classes exceptionnelles, tandis que les exceptions non vérifiées n'ont pas de classes exceptionnelles ou ne constituent pas une partie importante des classes exceptionnelles.
- Un exemple d'exception vérifiée serait une OutOfMemoryError, NullPointerException et StackOverflowError, alors qu'un exemple d'exception non vérifiée serait une exception IndexOutOfBoundsException.
Bibliographie
- https://ieeexplore.ieee.org/abstract/document/4343929/
- https://link.springer.com/article/10.1023/A:1010020917337
Dernière mise à jour : 11 juin 2023
J'ai mis tellement d'efforts à écrire ce billet de blog pour vous apporter de la valeur. Cela me sera très utile, si vous envisagez de le partager sur les réseaux sociaux ou avec vos amis/famille. LE PARTAGE C'EST ♥️
Sandeep Bhandari est titulaire d'un baccalauréat en génie informatique de l'Université Thapar (2006). Il a 20 ans d'expérience dans le domaine de la technologie. Il s'intéresse vivement à divers domaines techniques, notamment les systèmes de bases de données, les réseaux informatiques et la programmation. Vous pouvez en savoir plus sur lui sur son page bio.
La couverture complète des concepts d'exceptions cochées et non cochées, ainsi que leurs applications, fournit une compréhension complète. L'article aborde efficacement les aspects fondamentaux de ces exceptions en programmation.
L'explication de l'article selon laquelle les exceptions vérifiées sont des erreurs récupérables, telles qu'un fichier introuvable, et les exceptions non vérifiées sont des erreurs irrécupérables, comme une mémoire insuffisante, est pertinente et souligne l'importance de faire la distinction entre les deux.
L'article fournit des informations détaillées sur les exceptions cochées et non cochées, expliquant clairement en quoi elles diffèrent et quelles fonctions elles remplissent. Il explique également comment le compilateur gère les exceptions vérifiées au moment de la compilation et la responsabilité du programmeur dans la gestion des exceptions non vérifiées.
La discussion sur les exceptions vérifiées nécessitant un bloc try-catch ou un mot-clé throws alors que des exceptions non vérifiées se produisent au moment de l'exécution et n'ont pas besoin d'être gérées est instructive. Il souligne les scénarios potentiels d’apparition de chaque type d’exception.
L'explication détaillée des exceptions vérifiées faisant partie de la signature d'une méthode, alors que les exceptions non vérifiées n'en font pas partie, fournit des informations précieuses sur la nature de ces exceptions. L’article communique efficacement la distinction entre les deux.
L'article propose une analyse approfondie des exceptions vérifiées et non vérifiées, soulignant leur importance et leurs implications pour l'exécution du programme. La description claire aide à comprendre leurs rôles dans le développement et les tests de logiciels.
L'article présente un tableau comparatif complet qui décrit succinctement les différences entre les exceptions cochées et non cochées. Le tableau simplifie la compréhension des deux types d'exceptions, de leurs occurrences et de la manière dont elles sont traitées.
Les informations détaillées sur les exceptions vérifiées et non vérifiées, y compris la définition, l'occurrence et la gestion des erreurs, constituent une ressource précieuse pour ceux qui cherchent à approfondir leurs connaissances des principes de test et de programmation de logiciels.