Java: Ausnamen an hir Handhabung

All Programm funktionéiert nëmme stabil, wann hiren Sourcecode debugéiert gëtt an et gëtt keng Zoustännegkeeten, déi falsch Situatiounen verursaachen. De Prozess vu Fanghuelen méiglecherweis Feeler ass op der Programméiere gemaach. Fir dat ze maachen, de Entwéckler berücksichtigt all d'erwartete Resultater an probéiert d'Effekter vum Fehler ze limitéieren, sou datt et de Programm net bremsen oder zu senger Verrécklung féieren.

Wann Dir vläicht néideg Ausnahmen ergräife mussen

A Java kënnen Exceptiounen vu falschen Usereneingunge verursaacht ginn, net genuch vun der Ressource déi néideg ass fir de Programm ze lafen oder eng plötzlech Trennung vum Netz. Fir déi gemittlech Benotzung vun der Applikatioun vum Developer ass et néideg fir de Véierel vun aussergewéinleche Situatiounen ze kontrolléieren. De Konsument sollt net op de Programm hong goen, fir seng Aarbecht ze kompletéieren, verléiert Daten als Resultat vun ongeschlecpt Exceptiounen oder nëmmen d'oft Meldungen, déi eppes falsch getraff hunn.

Mat Ausnahm vun Java

Wat misst Dir uginn? D'Java Sprooch huet hir gebauter Ausnam-Funktionalitéit. Natierlech ginn e groussen Prozentsatz vu Feeler bei der Konstellatiounsstrooss fonnt, wann de System automatesch bericht huet, datt et net weider benotzt gëtt. Mee et gëtt och eng Aart vun Ausnahmen, déi während der Programmaktioun entstoen. De Entwéckler muss et fäerdeg kennen virstellen an den Code auszetauschen esou datt et e Fehler net verursaacht, mä behandelt et op eng speziell Manéier oder iwwer d'Kontroll vun enger anerer Branche.

Bei Java gëtt sou extrait vun Ausnamen vum Compiler opgemaach, sou typesch Problemer sinn bekannt an hunn hir eege Standard-Exekutiounsschema.

Typesch Ausnahmen

Am einfachsten Beispill kënnt Dir eng Ausnam deelhuelen. Trotz all senger Einfachheet, am Ausdrock, als Divisor, kann et Null ginn, wat zu engem Fehler féieren. Well, wann säin Aussoe méi fréi virgestallt a verhënnert gouf. Awer dës Optioun ass net ëmmer verfügbar, also ass et néideg fir d'Fangerausstellung direkt ze organiséieren wann eng "Divisioun duerch Null" geschitt.

De Java weist de Fehlerbehandlungsmechanismus wéi dëst:

• An der Heap gëtt e Ausnamobjekt geschaf, wéi och all aner;
• Den natierleche Kurs vum Programm gëtt ënnerbrach;
• Déi Ausnahmemechanismus probéiert eng alternativ Manéier ze fannen fir de Code weiderzemaachen;
• Déi Plaatz vu sécherer Ausféierung vum Programm am Handler fannen, d'Wierker entweder restauréiert ginn, oder eng Ausnahm gëtt op eng speziell Manéier umgesat.

Deen einfachste Beispill vu Schafe vun engem Fehler kéint ausgesi wéi dës:

Wann (a == null)

Awer nei NullPointerException ();

Hei gëtt d'Variabel e fir Initialiséierung gepréift, d. Ass net egal wéi d'Nummer referenzéiert. Am Fall wou dës Situatioun geschitt ass an eng speziell Veraarbechtung néideg ass, gëtt eng Ausnahm opgetrueden andeems d'nei NullPointerException () erausgeet.

E puer Detailer iwwer Schlësselwieder

Wann Dir mat Ausnamen geschafft hutt, musst Dir oft Java-Schlësselwieder benotze fir eng Aktioun ze bezuelen. Et gi fënnef dovunner an dëser Programmiersprache:

• Probéiert et. Dëst Schlësselwuert ass schonn erfëllt, an et heescht eng Transitioun an eng Rubrik vun Code datt eng Ausnam geheien kann. De Block ass limitéiert Acceleratioun {}.
• Catch. Et hänkt d'passend Zort Ausnahm an hir Prozesser.
• Endlech. Dëst Schlësselwuert ass optional an ass fir e Code ze féieren, deen an all Fall néideg ass, och wa keen Ausnam ofgeschnidden ass. Et gëtt direkt nodeems de Versuch blockéiert ginn.
• Throw - erlaabt Iech Java Ausnahmen irgendwou an de Code z'erreechen.
• Throws ass e Schlësselwuert deen an der Methode ënnerschriwwe gëtt. Et heescht, datt de spéideren Code d'Java-Ausnam vun der spezifizéierter Kategorie ausdrécken kann. Dëst Label ass als Signal fir Entwéckler, wat Dir braucht fir ze behalen - d'Methode wier net esou erwuess.

Catch mat probéiert

Déi Auslaaschtung vun der Java-Ausnam ass natierlech vun der Iwwerleeung datt se op eng speziell Manéier behandelt ginn. Déi bequemste Method fir dës ze maachen ass wann de Code Deel a blockéiert ass. Wat evitéiert eng Ausnahm. Wann Dir esou e Code ausféiert, fënnt d'virtuelle Maschinn eng onerwaart Situatioun, versteet datt et am kriteschen Block ass a kontrolléiert Kontroll an de Veraarbechtungsgebitt.

An Java ass de Code an engem spezielle Versuchsblock gewéckelt, an deem eng Ausnahm kann gewuer ginn ginn. Esou sinn et verschidden ongeforene Situatiounen plazéiert ginn, déi an enger eenzeger Plaz gefangen ginn, ouni de Code entzuet.

Déi typesch Code mat engem Veraarbechtungsblock kuckt wéi:

Probéiert {

// Dëst bestëmmt de Code, deen eng Ausnahm werfen

} Catch (Extraction_1_1 identifier_1) {

// Hei gëtt d'Ausnam verfollegt, no senger Aart a Konditioune;

} Catch (Extraction_type_2 identifier_2) {

// Hei gëtt d'Ausnam verfollegt, no senger Aart a Konditioune;

}}

D'Schlësselwuert informéiert datt de Code, deen de Ausnahmegespréich ausgesetzt ass, veraarbecht ginn, wéi et hei ënnendrënner beschriwwe gëtt, wann et mat senger Typ entsprécht. Den Identifizéierer kann an den Veraarbechtungscodeblock als Argumenter benotzt ginn.

Endlech

Wéi et vum fréiere Kapitel kloer ginn ass, fënnt d'Blödsblock Ausnahmen a veraarbecht se. Mee heiansdo ass eng Situatioun, wann e Code muss ausginn, egal ob d'Fehler fonnt goufen. Dofir ass et endlech de Schlësselwuert. Et gëtt benotzt fir d'Wäerter vu verschiddene Geschichten, enneren Fichieren oder Verbindungen am Netz ze erhéigen.

An dësem Sekt sinn et puer Fangerblöder mat erfonntene Methoden fir Fänke Ausnahmen. Zum Beispill gëtt de Code, deen an der Versammlung probéiert, eng onerwaart Situatioun vu Typ Kälte generéiert. Duerno sinn d'Ausdréck "Konnt kal erwëscht" an "Ass dat eppes fir ze fräien?" Sinn an der Konsole ze gesinn. Dat heescht, de schliisslechem Block gëtt an all Fall ausgeführt.

Tatsächlech ass et e Wee fir de schliisslech net ze féieren. Et bezitt sech op d'Enn vun der virtueller Maschinn. Fannt et eraus wéi dëst am Internet gemaach ginn.

D 'Schlësselwuert

Ee Spiller wéckelt eng Ausnahm. Säin Syntax sieft esou:

Awer nei NewExcept ();

Hei gëtt eng nei Ausnahm op den Typ NewException () erstellt. Als Typ kann Dir Klassen sinn, déi schon an de Standard Java-Bibliothéiken agefouert hunn a fréi vum Développement vun Ärer eegener Produktioun definéiert sinn.

Sou eng Konstruktioun ass an der Beschreiwung vun all Methode matgedeelt, wou säin Uruff muss am Versuchsblock stattfannen, fir se ze kapten.

Schlësselwuert dréit

Wat fir ze maachen wann am Entwécklungsprozess et eng Situatioun gëtt, wou d'Methode eng Ausnahm erauszitt, awer kann et net korrekt behandelen. Fir dat ze maachen, befënnt d'Methodsënnerstëtzung d'Wuert Throws a d'Typ vun der méiglecher Ausnahm.

Dëse Label ass eng Zort vun Zeechner fir Cliente Entwéckler datt d'Methode net fähig ass seng eegen Ausnam ze veraarbecht. Zousätzlech, wann de Fehlertyp iwwerpréifbar ass, gëtt de Compiler kloer explizéiert.

Probéiert mat Ressourcen

A Java Version 7 huet d'Entwéckler sou eng wichteg Innovatioun wéi d'Veraarbechtung vum Versuchsblock mat Ressourcen.

Viele vun den Objeten, déi zu Java erstellt sinn, no hirer Benotzung, musse gespaart ginn fir Ressourcen ze spueren. Virdrun musst Dir dës Instanzen manuell iwwerdenken a stoppen. Elo hunn si eng Interface AutoClosable. Et hëlleft automatesch scho gebraucht Objeten automatesch zou, déi am Versuchsblock gesat ginn. Duerch dës Approche ass et méi praktesch, de Code ze schreiwen, seng Liesbarung huet de Leit erheblech erhéicht.

Benotzerdefinéiert Java Ausnam Klassen

D'Creatoren vun der beschriwwe Programméierungssprooch hunn vill Aspekter berücksichtegt wann Dir Typen vun onverfollege Situatiounen entwéckelt. All Varianten vum Resultat vun Evenementer kënnen net verhënneren, also an Java, ass et méiglech hir eege Ausnahmen ze erméiglechen, déi fir d'Besoine vun engem spezifesche Code sinn.

Déi einfachste Manéier ze kreéieren ass d'Ierfschaft vum Objet am meeschten passend zum Kontext.

Hei musst Dir vun der Ausnam verroden, eng Klass, déi benotzt gëtt fir Är eege Ausnahmen ze definéieren. An MyException ginn et zwee Konstruktoren - one by default, déi zweet - mat Argument vun msg Typ String.

Duerno an der Public Class FullConstructors gëtt d'Methode f ëmgesat, déi Ënnerschrëft vun deenen enthält MyException. Dëst Schlësselwuert heescht, datt f eng Java Ausnam vun Typ MyException werfen. Weider, am Kierper vun der Methode, gëtt Textinformatioun op d'Konsole an d'tatsächlech Generatioun vu MyException, duerch d'Drénk.

Déi zweet Method ass liicht ënnerschiddlech vun der éischter an, wann eng Ausnahm ofgeworf gëtt, gëtt et e Stringparameter, deen an der Konsole reflektéiert gëtt, wann se ageholl ginn. An haaptsächlech gesitt Dir datt f () a g () am Versuchsblock plazéiert sinn an de Schlësselstull ass fir MyException ze gesinn. D'Resultat vun der Veraarbechtung ass d'Ausgaang vun der Fehlermeldung an der Konsole:

Dofir war et méiglech Java-Ausnamen ze addelen, déi vun der eegener Hand geschaaft ginn.

Ausnam Architektur

Like all Objeten an Java, ginn Ausnamen och geerbt an eng hierarchesch Struktur. De Root-Element vun all Feeler aus der Programmiersprache verwierklecht ass d'java.lang.Dréierbar Klass. Et ierft zwee Arten - Error an Exceptioun.

Feeler - Benotzung iwwer kritesch Fehler an representéiert Java-Ausnamen net ofgeschaaft. D'Interceptioun an d'Veraarbechtung vun dësen Donnéeën an de meeschte Fäll fällt op der Entwécklung an ass net erfuerderlech am Code vun der Final Applikatioun.

Déi am allgemengen benotzt Klasse fir Ausnamen ze schafen an ze analyséieren ass Ausnam. Wat en ëm en Ënnerscheed an verschiddene Filialen, dorënner d'RuntimeExcept. RuntimeException befaasst Runtime-Ausnahmen, dat heescht, déi während dem Programm lafen. All Klassen, déi geernannt sinn, sinn net verifizéiert.

Gemeinsam Ausnahmen

Aus Ausnahm vun Java, déi Lëscht hei ënnendrënner genannt gëtt, ginn am meeschten benotzt, also ass et wichteg, all eenzel Detailer ze beschreiwen:

• ArithmeticExcept. Dëst beinhaltlech Fehler mat arithmetesche Betriber. Déi bescheidend Beispill ass d'Divisioun duerch Null.
• ArrayIndexOutOfBoundsException - Zougang zu der Zuel vun dem Element vun der Array, déi hir Gesamlängt überschrennt.
• ArrayStoreExcept - e Versuch, e Grupp vun engem onkompatiblen Typ ze weisen.
• ClassCastException ass e Versuch, een Typ op eng aner ze verzerren.
• IllegalArgumentException - Benotze vun engem ongëlteg Argument an der Methodsufro.
• NegativeArraySizeException ass eng Ausnam bei der Schaffung vun engem Array vu negativ Gréisst.
• NullPointerException - falsch Benotzung vun Netziel Referenz.
• NumberFormatException - geschitt wann d'String net zu enger Nummer ëmgewandelt gëtt.
• Net Support ënnerstëtzt OperatiounExceptioun - d'Operatioun gëtt net ënnerstëtzt.

Dës Beispiller ginn net gekuckt Typen vun Exceptiounen Java. Also kucken iwwerpréift:

• ClassNotFoundExcept - Klass net fonnt.
• IllegalAcccessExcept - Zougang zu der Klass.
• InterruptedExcept - Ënnerbriechung vum Flow.
• NoSuchFieldExcept - d'Feld ass net existéiert.

Interpretatioun vu Ausnahmen

Mir schwätzen iwwer gemeinsame Ausnahmen, datt hir Interpretatioun während der Entwécklung ka falsch sinn. Als nächstes gëtt et eng kleng Lëscht, déi méi detailléiert erkläert gëtt, wann eng ongeféierlech Situatioun opstinn.

NullPointerException. Déi éischt Kéier, datt eng Ausnahm statt ass, ass op eng Objekt Referratioun referenzéiert déi null ass. Dëst gëllt och fir d'Methode vun der Nullinstanz vun der Klass. E NullPointerException ka ginn a wa si d'Längt vum Array ass null. Vermeiss esou Situatiounen duerch periodesch Préift Objeten op Null.

ArrayIndexOutOfBoundsException. All Programm kann net existéieren ouni Arrays benotzen. Dofir ass eng heefeg Referenz zu hinnen e Fehler. Eng Ausnahm stattfënnt wann de Entwéckler probéiert op en Array Element deen net an der Index Lëscht erlaabt ass. Zum Beispill ass de gewënschten Wäert iwwer d'Längt oder manner wéi Null. Et schéngt oft als Resultat vun der Tatsaach, datt de Grof an dem Array vun Null ufänkt.

Conclusiounen

Ausnahmebehandlung Java ass e kinneklechen Ëmfeld, deen d'Aarbecht vum Programmierer erliichtert erlaabt a him e klengen a fehlerfreien Code ze kreéieren. De Status an d'Reputatioun vun der Entwéckler Firma hänkt dovun of wéi flott a stabil ass d'Applikatioun funktionnéiert.

Natierlech, an méi oder manner einfache Programmer ass et vill méi einfach e Freelance Situatiounen ze verfolgen. Mä an grouss automatiséiert Komplexe fir eng méi honnertdausend Linnen, ass dat nëmme méiglech als Resultat vu laangfristeg Debuggen an Tester.

Fir Ausnahm vu Java, Fehlzeechen déi an e puer Applikatiounen entstinn, ginn eenzel Entreprisen nach belount, wann se Begeeschterten sinn. Besonnesch schätzen sinn déi, déi Verstouss géint d'Sécherheetspolitik vun der Software Komplex verursaachen.