Comment lancer une exception dans Java

Une exception est une erreur potentielle, dont le système Java signale le programme Java. Si l'exception (erreur) n'est pas gérée, le fil concerné cessera de fonctionner. Si le programme était unique, alors le programme cesserait de fonctionner. Considérez le programme suivant: classe publique TheClass
public static void main (String [] args)
Système.dehors.println ("vu 1");
int numérateur = 6;
int denominator = 0;
int quotient = numérateur / dénominateur;
Système.dehors.println ("vu 2");
Système.dehors.println (quotient);

Ce programme essaie de diviser par 0 à la quatrième déclaration de la méthode Main (). En mathématiques, aucun nombre ne doit être divisé par 0. Les ordinateurs ne permettent pas non plus cela. Ce programme doit imprimer «Vu 1», alors si la division par zéro est possible par l'ordinateur, le programme doit imprimer «vu 2», puis imprimer le quotient de 6 divisé par zéro.

Ce programme est compilé avec succès par le compilateur Javac. Cependant, lorsque le programme est exécuté par la machine virtuelle Java (système d'exploitation), «Vu 1» est imprimé, et le programme s'arrête à la quatrième déclaration, où la division par zéro est attendue, d'où (où et puis) ​​un message d'erreur est émis (affiché). Le programme cesse de s'exécuter sur la déclaration de division par zéro, imprime un message d'erreur et cesse de fonctionner. Après cela, les deux dernières déclarations ne sont pas exécutées (ne fonctionnent pas).

Cependant, s'il s'agissait de multiplication par zéro, ce qui est autorisé, alors les deux dernières déclarations auraient été exécutées. Cet article fournit les bases du lancement et de la gestion d'une exception à Java.

Gestion des erreurs

Avec Java, il est possible de gérer une erreur, comme la division par zéro, avec un code simple; de sorte que les instructions (codage) après l'erreur doivent fonctionner (être exécutée). Quelle est l'erreur ici? - L'erreur ici est division par zéro. Le code (solution) par le programmeur ne doit pas autoriser l'erreur. Le programmeur doit coder ce que l'on appelle l'erreur, qui est un nouvel objet d'exception. L'objet d'exception doit être capturé. Lorsque l'objet d'exception est capturé, le programme doit s'en remettre. Se remettre d'une erreur signifie gérer l'exception.

La classe de bibliothèque d'exception gère l'erreur plus que le programmeur. La classe d'exception n'a pas à être importée au début du programme. Cette importation se fait automatiquement, sans l'aide du programmeur.

La classe d'exception

Il y a deux classes de gestion des erreurs principales dans Java: la classe d'exception et la classe d'erreur. Cet article ne traite que de la classe d'exception. En tant que personnage, la classe d'exception connaît des erreurs ordinaires, telles que les valeurs nulles de division par zéro et indésirables dans une chaîne littérale.

Lorsqu'un nouvel objet d'exception est lancé, juste après l'instruction qui entraînerait une erreur, la bibliothèque de classe d'exception connaîtrait l'erreur; Si c'est une erreur ordinaire. La classe d'exception n'a pas à être importée au début du programme. Cette importation se fait automatiquement, sans l'aide du programmeur.

La déclaration de Java Try

L'énoncé d'essai est une déclaration composée, composée du bloc d'essai et d'un blocage. Sous une forme simplifiée, la syntaxe est:

essayer
// Instruction Problème;
lancer une nouvelle exception ();
* instructions si aucune erreur ne se produit *

attraper (exception e)
Système.dehors.println ("Message d'exception:" + e.getMessage ());

Essayer est un mot réservé; Catch est un mot réservé. Le bloc d'essai a la déclaration de problème. Une déclaration comme,

int quotient = numérateur / dénominateur;

est une déclaration de problème. Si le dénominateur n'est pas nul, aucune erreur ne se produit. Si le dénominateur est nul, c'est une erreur. La déclaration de lancer serait généralement,

lancer une nouvelle exception ();

Cette déclaration de lancer devrait venir immédiatement après l'énoncé du problème. Si une erreur se produit, l'instruction Throw lance un nouvel objet d'exception. Notez les parenthèses. Si le dénominateur est 0, un nouvel objet d'exception est lancé. En dessous de l'instruction Throw se trouvent d'autres instructions qui seraient exécutées si aucune erreur ne se produisait.

Le bloc-cordage ci-dessus a une déclaration. Il peut avoir plus. L'instruction de lancer dans le bloc d'essai jette un objet d'exception, qui est pris dans les parenthèses de la signature du bloc de capture, pour un traitement ultérieur dans son bloc. Cette activité est similaire à un appel de méthode, avec un argument à recevoir par les parenthèses de la mise en œuvre de la méthode pour un traitement ultérieur dans le bloc de la méthode.

N'oubliez pas que l'objet d'exception peut reconnaître différents types d'erreurs ordinaires et y faire face. L'objet d'exception a la méthode, getMessage (). Cette méthode renvoie un message que l'utilisateur peut comprendre comme la cause de l'erreur. Cet appel de méthode est utilisé à l'intérieur du blocage.

Le programme suivant met en pratique la déclaration de compound Try-Compound, avec le problème de division par zéro ci-dessus:

classe publique TheClass
public static void main (String [] args)
Système.dehors.println ("vu 1");
int numérateur = 6; int denominator = 0; int quotient;
essayer
if (denominator == 0)
quotient = numérateur / dénominateur;
lancer une nouvelle exception ();

autre
quotient = numérateur / dénominateur;
Système.dehors.println ("vu 2");
Système.dehors.println (quotient);

attraper (exception e)
Système.dehors.println ("Message d'exception:" + e.getMessage ());

Système.dehors.println ("continue");

Le bloc d'essai a une déclaration IF-compound. La partie if exécuterait l'instruction Problème lorsque le dénominateur est nul. La partie else exécuterait l'instruction du problème lorsqu'aucune erreur ne se produirait lorsque le dénominateur n'est pas nul. Cela signifie que le programmeur doit guider l'emploi du système de gestion des exceptions. Et donc, dans ce cas, l'énoncé du problème a été tapé deux fois: une fois dans la partie if et une fois dans l'essentiel. L'énoncé du problème n'est pas précédé par INT car le quotient a été déclaré avant l'énoncé du composé d'essai.

Dans le bloc d'essai, l'instruction Throw est juste en dessous de l'instruction Problème dans la partie if de la déclaration IF-Compound. Ce n'est pas dans la partie else de la déclaration IF-compound. Il n'a pas besoin d'être là parce que la partie else est pour la situation où le dénominateur (opérande) n'est pas nul (n'a pas de problème).

Lisez le programme ci-dessus. Le numérateur est 6. Si le dénominateur était de 2, la sortie aurait été:

vu 1
vu 2
3
Continue

Cela signifie que l'autre partie de la déclaration IF-Compound a été exécutée, et non la partie if de la déclaration IF-Compound. En fait, le sf if (code) de la déclaration de composé IF n'a pas été exécuté parce que le dénominateur n'était pas nul. Le reste du code dans le bloc d'essai a été exécuté. Le reste du code dans le bloc d'essai est censé être exécuté.

Lorsque le dénominateur est 0, le programme produira la sortie:

vu 1
Message d'exception: / par zéro
Continue

Seul le code de la partie if du bloc d'essai a été exécuté dans cette situation. Cela signifie que la déclaration de lancer a été exécutée. L'essemblance Else et le code sous l'instruction IF-Compound n'ont pas été exécutés. Ils ne sont pas normalement exécutés dans cette situation.

Le bloc de caisse n'est pas exécuté lorsqu'il n'y a pas de problème. Maintenant, le bloc-cordant a été exécuté. C'est-à-dire que le code d'instruction unique dans le blocage a été exécuté. Le nouvel objet d'exception est lancé, a été reçu comme e. La méthode getMessage () de l'objet, E qui connaît les erreurs ordinaires (y compris l'erreur de division par zéro) a renvoyé le message, «/ par zéro».

Avec cette erreur renvoyée Message, l'utilisateur saurait qu'une erreur de division par zéro s'est produite et elle a été gérée. La gestion, ici, signifie que la division par zéro n'a pas causé de mal au programme et, bien que le reste du code sous le point d'erreur dans l'instruction Try-Compound ne soit pas exécuté, le code sous l'essai- La déclaration composée serait exécutée. Si le schéma de manutention n'était pas présent, le programme aurait fait fin et tout code ci-dessous n'aurait pas été dans la déclaration de compound Try-Compound n'aurait pas été exécuté.

Lancer une exception, par une méthode

En Java, l'instruction Throw-Exception peut lancer une exception dans le bloc d'essai, comme illustré ci-dessus. Une méthode peut également lancer une exception, mais avec une syntaxe différente, toujours liée au bloc d'essai. Le cœur du code d'essai est maintenant dans le corps de la méthode et non dans le bloc d'essai. Le programme suivant répète celui ci-dessus, mais avec une méthode lançant l'exception. La classe avec l'implémentation de la méthode est:

classe ACLASS
int mthd (int nume, int neno) lève l'exception
int quoti = nume / deno;
return quoti;

Le code principal de la méthode ici est l'instruction Problème. L'énoncé du problème n'est plus dans le bloc d'essai (ci-dessous). L'énoncé du problème a été tapé une fois, ici, et pour l'ensemble du programme (non tapé deux fois). L'expression de lancer est maintenant différente. C'est,

lance l'exception

prolonger la signature de la méthode à droite. «Lancer» ici est «lance», avec un s. Exception, ici, n'a pas les parenthèses.

Il n'y a plus besoin de la déclaration IF-compound dans tout le programme. Le corps de la méthode et «l'exception des lancers» servent le but de la sémantique de l'énoncé du composé IF-Else. La classe principale devient:

classe publique TheClass
public static void main (String [] args)
Système.dehors.println ("vu 1");
int numérateur = 6; int denominator = 0; int quotient;
essayer
AclasseObj = new aclass ();
quotient = eobj.MTHD (numérateur, dénominateur);
Système.dehors.println ("vu 2");
Système.dehors.println (quotient);

attraper (exception e)
Système.dehors.println ("Message d'exception:" + e.getMessage ());

Système.dehors.println ("continue");

Il a toujours la déclaration de composé d'essai. Cependant, l'énoncé du problème n'est pas là et n'est pas tapé deux fois. L'énoncé du composé IF-Else n'est pas non plus ici. Il n'est plus nécessaire nulle part dans le programme. La sortie avec son message d'erreur est la même qu'avant, je.e.

vu 1
Message d'exception: / par zéro
Continue

Le comportement du programme complet est comme avant.

La clause enfin

L'énoncé d'essai a trois clauses: la clause d'essai, la clause de capture et la clause enfin. Il peut y avoir plus d'une clause de capture - voir plus tard. Le bloc enfin vient à la fin de l'instruction Try-Compound, et il appartient au programmeur de transmettre un message à l'utilisateur que l'erreur possible a été gérée. Le codage de la clause enfin est facultatif. Le code suivant illustre une utilisation de la clause enfin pour le programme ci-dessus:

Système.dehors.println ("vu 1");
int numérateur = 6; int denominator = 0; int quotient;
essayer
AclasseObj = new aclass ();
quotient = eobj.MTHD (numérateur, dénominateur);
Système.dehors.println ("vu 2");
Système.dehors.println (quotient);

attraper (exception e)
Système.dehors.println ("Message d'exception:" + e.getMessage ());

enfin
Système.dehors.println ("Toute erreur a été gérée.");

Si le dénominateur est 2, la sortie serait:

vu 1
vu 2
3
Toute erreur a été gérée.
Continue

Si le dénominateur est 0, la sortie serait:

vu 1
Message d'exception: / par zéro
Toute erreur a été gérée.
Continue

Le bloc enfin est exécuté, si une erreur s'est produite ou non.

Conclusion

Une exception est lancée, avec la déclaration simple dans le bloc d'essai, éventuellement codé avec une instruction IF-Compound et l'instruction Problème. Une exception peut encore être lancée par une méthode par rapport à la déclaration de compoup Try-Compound. Cet article a été les bases de lancer une exception à Java.