Java: exceptions et leur manipulation

Tout programme fonctionnera de manière stable uniquement si le code source est débogué, et il n'y a pas de conditions qui peuvent causer des situations imprévues. Le processus de rattrapage des défaillances possibles est effectuée sur la scène de programmation. Pour ce faire, le développeur tient compte de toutes les résultats attendus et tente de limiter l'effet de l'erreur afin qu'il ne pouvait pas interférer avec le fonctionnement du programme, ou conduire à son effondrement.

Lorsque vous pourriez avoir besoin la gestion des exceptions

En Java, une exception peut être causée par l'entrée d'utilisateur incorrect, pas besoin d'un programme de déconnexion du réseau des ressources ou soudaine. Pour une utilisation confortable créée par le développeur d'applications, vous devez contrôler l'apparition de situations d'urgence. Le consommateur ne devrait pas avoir à attendre pour quitter une application, de perdre des données à la suite d'une exception non gérée, ou tout simplement partie d'un message indiquant que quelque chose a mal tourné.

Gestion des exceptions Java

Que prendre en compte? Le langage Java a sa propre fonctionnalité de gestion des exceptions intégrée. Bien sûr, un grand pourcentage d'erreur est pris par une autre étape de compilation, le système avertira automatiquement que l'utilisation est plus possible. Mais il y a ce genre d'exception qui se produit lors de l'exécution. Le développeur devrait être en mesure d'anticiper et de concevoir le code afin qu'il ne provoque pas une erreur, et la manipulation d'une façon spéciale et remis le contrôle à une autre branche.

En Java, cela est imposé par le compilateur pour intercepter une exception, de sorte que les problèmes typiques sont connus et ont un modèles d'exercice standard.

exclusions typiques

L'exemple le plus simple, dans lequel vous pouvez obtenir une exception – cette division. Malgré sa simplicité, en termes, en tant que diviseur, peut être nul, ce qui entraînera une erreur. Eh bien, s'il est possible de prédire l'émergence du passé et de prévenir. Mais cette option n'est pas toujours disponibles, attrapant l'exception devrait être organisée directement en cas de « division par zéro ».

Le mécanisme Java pour intercepter l'erreur de traitement ressemble à ceci:

• tas objet d'exception est créé, ainsi que toute autre;
• le cours naturel du programme est interrompu;
• mécanisme d'exclusion tente de trouver une autre façon de continuer le code;
• Trouvez une exécution sûre du programme dans le processeur, le travail ou restauré, ou aura lieu la réalisation d'exception d'une manière spéciale.

L'exemple le plus simple de créer une erreur pourrait ressembler à ceci:

si (a == null)

throw new NullPointerException ();

Ici, la variable a est vérifiée lors de l'initialisation, à savoir, est pas si la référence à un objet nul. Si cette situation a été soulevée et ont besoin d'un traitement spécial, une exception est levée par un jet nouveau NullPointerException ().

Peu de détails sur les mots clés

Lorsque vous traitez avec des exceptions est souvent nécessaire d'utiliser Java mot-clé pour faire référence à une action particulière. Cette langue de leur cinq programmes:

• Essayez. Ce mot clé est déjà remplie, et cela signifie une transition vers une section de code qui peut lancer une exception. Bloc accolades {} limitées.
• Catch. Il intercepte le type d'exception souhaitée et gérer de manière appropriée.
• Enfin. Ce mot-clé est facultative et est utilisé pour effectuer un certain morceau de code, qui est nécessaire de toute façon, même si aucune exception n'est pas pris. Ajouté directement après le bloc d'essai.
• Jeté – vous permet de créer Java exceptions où que vous soyez.
• Lancers francs – un mot-clé qui est placé dans la signature de méthode. Cela signifie que le code suivant peut lancer une exception de ce type Java. Cette marque sert de signal pour les développeurs qui doivent garder à l'esprit – la méthode ne peut pas fonctionner comme prévu de lui.

Attraper avec un essai

Sortie des exceptions Java, suppose naturellement qu'il sera traité d'une manière spéciale. La façon la plus pratique de le faire, si la section de code est clôturée dans un bloc. Ce qui peut contenir une exception. Lorsque vous exécutez ce code, la machine virtuelle trouvera une situation inattendue, comprendre qu'il ya un bloc critique et transfère le contrôle à la station avec le traitement.

Le code Java est enveloppé dans un essai de bloc spécial, dans lequel peut être une exception. Ainsi, il a placé plusieurs situations imprévues qui seront pris dans le même endroit, pas le code de raspolzayas.

Le code le plus typique de l'unité de traitement est la suivante:

try {

// Voici un code qui peut générer une exception

} Catch (Tip_isklyucheniya_1 identifikator_1) {

// Ici, il y a la gestion des exceptions, en fonction de son type et les conditions;

} Catch (Tip_isklyucheniya_2 identifikator_2) {

// Ici, il y a la gestion des exceptions, en fonction de son type et les conditions;

}

capture les mots-clés indique que le code et le scanner pour une exception, à traiter comme décrit ci-dessous, à condition qu'il soit conforme à son type. L'identificateur peut être utilisé dans le traitement du bloc de code comme arguments.

enfin

Comme il est devenu clair du chapitre précédent, les blocs de capture intercepter des exceptions et les traiter. Mais très souvent, la situation se présente où doit exécuter un code, peu importe qu'ils soient ou non pris des erreurs. Pour cela, il y a le mot-clé finalement. Il est utilisé pour augmenter les valeurs des différents compteurs, la fermeture des dossiers ou des connexions réseau.

Cette parcelle présente plusieurs blocs catch ont inventé des méthodes attrapent des exceptions. Par exemple, le code contenu dans l'essai génère une situation inattendue comme Cold. Ensuite, la console affichera l'expression «enrhumé!» Et «Est-ce de quoi se réjouir?». Autrement dit, le bloc finally est exécuté dans tous les cas.

En fait, une façon d'éviter le déclenchement enfin là. Il est relié à l'achèvement de la machine virtuelle. Trouvez comment le mettre en œuvre, il est possible sur les espaces Internet.

mot-clé Throw

Touche génère une exception. Sa syntaxe est la suivante:

throw new NewException ();

Il est créé une nouvelle exception à la NewException de type (). Comme un type peut être utilisé est déjà inclus dans les classes de la bibliothèque standard Java et défini précédemment par le développeur de sa propre production.

Cette conception fait partie de la description de toute méthode, l'appel doit alors se produire dans le bloc d'essai, afin de pouvoir l'intercepter.

mots-clés jette

Et si dans le processus de développement d'une situation où la méthode peut lancer une exception, mais ne sont pas capables de gérer correctement. A cet effet, dans la signature de méthode spécifie le mot lance et le type d'exceptions possibles.

Cette étiquette est une sorte d'indicateur pour les développeurs de clients que la méthode n'est pas en mesure de gérer leur même exception. De plus, si le type d'erreur est cochée, le compilateur forcera demander explicitement.

Essayez de ressources

Les développeurs Java version 7 ont inclus une innovation majeure, comme un bloc d'essai de traitement avec des ressources.

De nombreux objets sont créés en Java, après l'utilisation doit être arrêté pour économiser les ressources. Auparavant, il fallait tenir compte et arrêter ces instances manuellement. Maintenant, cependant, ils sont apparus l'interface AutoClosable. Il aide à fermer automatiquement les objets déjà utilisés placés dans un bloc d'essai. Grâce à cette approche, il est devenu plus commode d'écrire du code dans sa lisibilité est augmentée de manière significative.

les classes Java propres exceptions

Les créateurs du langage de programmation décrit pris en compte de nombreux aspects des types de conception des situations d'urgence. Cependant, toutes les options pour éviter l'issue des événements ne fonctionnera pas, donc en Java mis en œuvre la possibilité de définir leurs propres exceptions, il convient aux besoins du code particulier.

La façon la plus simple de créer – d'hériter de la plus appropriée au contexte de l'objet.

Il est arrivé à hériter d'exception, la classe qui est utilisée pour définir vos propres exceptions. Dans MyException a deux constructeurs – un défaut, la seconde – avec le type msg argument String.

Ensuite, dans la méthode FullConstructors en classe publique mis en œuvre f, qui contient la signature jette MyException. Ce mot-clé signifie que f peut jeter comme exception Java MyException. En outre, dans le corps de la méthode produit sortie de l'information de texte sur la console elle-même et la génération réelle MyException, par un jet.

La seconde méthode est légèrement différente de la première que lors de la création d'une exception, il est transmis un paramètre de chaîne, qui se reflète dans la console à attraper. Dans le principal, il est clair que f () et g () sont placés dans une vérification de mot-clé try et catch configuré pour capturer MyException. Le résultat du traitement est d'afficher un message d'erreur à la console:

Ainsi, il est venu d'ajouter Java exceptions, par sa propre main.

exceptions Architecture

Comme avec tous les objets Java, des exceptions sont également héritées et ont une structure hiérarchique. L'élément racine de toutes les erreurs lancées dans ce langage de programmation est classe java.lang.Throwable. Hérité de lui deux types – Erreur et Exception.

Erreur – signale l'erreur critique et est des exceptions Java non vérifiées. L'interception et le traitement de ces données dans la plupart des cas se produit au stade de la conception et n'a pas besoin d'introduire dans le code final de l'application.

La classe la plus couramment utilisée pour la création et l'analyse des exceptions est une exception. Ce qui, à son tour, est divisée en plusieurs branches, dont RuntimeException. Par RuntimeException sont des exceptions d'exécution, à savoir, survenant au cours du programme. Toutes les classes dérivées de celui-ci sont invérifiables.

Souvent, il y a des exceptions

Dans Java exceptions, dont la liste est présentée ci-dessous, sont utilisés le plus souvent, vous devez donc décrire chacun d'eux en détail:

• ArithmeticException. Ceux-ci comprennent les erreurs associées aux opérations arithmétiques. L'exemple le plus flagrant – la division par zéro.
• ArrayIndexOutOfBoundsException – un appel au numéro d'élément de réseau qui dépasse le total de sa longueur.
• ArrayStoreException – tentative d'attribuer un type d'élément incompatible du tableau.
• ClassCastException – une tentative de faire le mauvais type à un autre.
• IllegalArgumentException – en utilisant le mauvais argument dans l'appel de méthode.
• NegativeArraySizeException – une exception lorsque vous créez un tableau de taille négative.
• NullPointerException – abus de références à null.
• NumberFormatException – se produit quand une mauvaise conversion de chaîne en nombre entier.
• UnsupportedOperationException – opération n'est pas pris en charge.

Ces exemples représentent les types d'exceptions Java non vérifiées. Mais alors regardez vérifié:

• ClassNotFoundException – Classe introuvable.
• IllegalAcccessException – restreindre l'accès à la classe.
• InterruptedException – interruption du flux.
• NoSuchFieldException – il n'y a pas un champ obligatoire.

L'interprétation des exceptions

Parlant des exceptions fréquemment rencontrées convient de noter que leur interprétation dans la conception, peut être mal perçu. Vient ensuite une courte liste expliquant plus en détail, où il peut y avoir une situation inattendue.

NullPointerException. Le premier cas où il existe une exception, est de faire appel à une référence à un objet qui est égale à NULL. Elle étend également aux zéro méthodes d'instance de classe. NullPointerException peut être jeté dans le cas de l'obtention d'une longueur égale matrice nulle. Pour éviter de telles situations vérifiera périodiquement les sites sur la valeur nulle.

ArrayIndexOutOfBoundsException. Tout programme ne peut exister sans l'utilisation de tableaux. En conséquence, le recours fréquent à elle peut générer et erreur. Exception se produit quand un développeur tente d'accéder à un élément de réseau qui ne sont pas dans la liste d'index. Par exemple, la valeur est supérieure ou inférieure à zéro longueur. est très souvent le résultat du fait que dans le tableau commence avec un score de zéro.

résultats

Gestion des exceptions Java – un environnement puissant outil, ce qui facilite grandement le travail du programmeur et lui permet de créer un environnement propre et sans erreurs de code. Sur la façon dont l'application de bon fonctionnement et stable dépend du statut et la réputation du développeur.

Bien sûr, dans une situation plus ou moins des programmes simples pour tracer anormaux beaucoup plus facile. Mais dans les grands complexes automatisés pour quelques centaines de milliers de lignes, il est possible qu'à la suite d'essais à long terme et le débogage.

Java erreur d'exception à partir de laquelle se posent dans certaines applications, certaines entreprises offrent une récompense quand ils trouvent amateurs. Particulièrement apprécié par ceux qui causent une violation du logiciel de la politique de sécurité.