Java: undantag och deras hantering

Alla program fungerar stabilt endast om källkoden är debugged, och det finns inga villkor som kan orsaka oförutsedda situationer. Processen att fånga eventuella fel uppstår vid programmeringssteget. För att göra detta tar utvecklaren hänsyn till alla förväntade resultat och försöker begränsa effekten av felet så att det inte kan bryta programmet eller leda till att det sammanfaller.

När du kanske behöver hantera undantag

I Java kan undantag orsakas av felaktig användarinmatning, brist på resurs som krävs för att köra programmet eller en plötslig avkoppling av nätverket. För den bekväma användningen av applikationen skapad av utvecklaren är det nödvändigt att kontrollera förekomsten av extraordinära situationer. Konsumenten bör inte vänta på att det hängda programmet ska slutföra sitt arbete, förlora data till följd av obehandlade undantag eller bara de ofta förekommande meddelandena att något gick fel.

Hantering av Java-undantag

Vad ska övervägas? Java-språket har sin inbyggda undantagshanteringsfunktionalitet. Självklart fångas en stor andel av fel på samlingsstadiet, då systemet automatiskt kommer att rapportera att det inte kan användas vidare. Men det finns också sådana slags undantag som uppstår under programoperationen. Utvecklaren måste kunna förutse detta och utforma koden på ett sådant sätt att det inte orsakar fel, men behandlar det på ett speciellt sätt eller skickar kontroll till en annan filial.

I Java införs sådan fångst av undantag av kompilatorn, så typiska problem är kända och har ett eget standardutföringsschema.

Typiska undantag

Det enklaste exemplet där du kan få ett undantag är division. Trots all sin enkelhet, i uttryck, som divisor, kan det finnas noll, vilket kommer att leda till ett fel. Tja, om hans utseende kan förutsägas tidigare och förhindras. Men det här alternativet är inte alltid tillgängligt, så det är nödvändigt att organisera det fångande undantaget omedelbart om en "division by zero" inträffar.

I Java ser felmekanismen ut så här:

• I högen skapas ett undantagsobjekt, liksom alla andra;
• Programmets naturliga förlopp är avbrutet;
• Undantagsmekanismen försöker hitta ett alternativt sätt att fortsätta koden.
• Om du hittar platsen för ett säkert genomförande av programmet i hanteraren, kommer arbetet antingen att återställas, eller ett undantag kommer att genomföras på ett speciellt sätt.

Det enklaste exemplet på att skapa ett fel kan se ut så här:

Om (a == null)

Kasta ny NullPointerException ();

Här kontrolleras variabeln a för initialisering, d.v.s. Är inte lika med nollreferensen. I händelse av att denna situation uppstår och speciell behandling behövs, kastas ett undantag med kasta ny NullPointerException ().

Några detaljer om nyckelord

När du arbetar med undantag måste du ofta använda Java-nyckelord för att referera till en åtgärd. Det finns fem av dem på detta programmeringsspråk:

• Försök. Det här sökordet har redan uppstått och innebär att det går till en sektion av kod som kan ta ett undantag. Blocket är begränsat till lockiga hängslen {}.
• Catch. Den hakar av lämplig typ av undantag och behandlar det i enlighet med detta.
• Slutligen. Detta nyckelord är valfritt och tjänar till att utföra en kod som är nödvändig, även om inget undantag är avlyssnat. Det läggs till omedelbart efter försöksblocket.
• Kasta - tillåter dig att skapa Java-undantag var som helst i koden.
• Kasta är ett nyckelord som placeras i metodens signatur. Det betyder att den efterföljande koden kan slänga ut Java-undantaget för den angivna typen. Denna etikett fungerar som en signal för utvecklare, vad du behöver tänka på - metoden kanske inte fungerar som förväntat.

Fånga med försök

Att kasta i Java-undantag förutsätter naturligtvis att det kommer att behandlas på ett speciellt sätt. Det lämpligaste sättet att göra detta är om kodavsnittet är partitionerat till ett block. Vilket möjligen innehåller ett undantag. När en sådan kod utförs, hittar den virtuella maskinen en oväntad situation, förstår att den befinner sig i det kritiska blocket och överför kontrollen till bearbetningsområdet.

I Java är koden insvept i ett speciellt provblock, inom vilket ett undantag kan kastas. Sålunda placeras flera oförutsedda situationer i den, som kommer att fångas på ett ställe, utan att krypa längs koden.

Den mest typiska koden med ett behandlingsblock ser ut så här:

Försök {

// Detta bestämmer koden som kan ta ett undantag

} Catch (Extraction_1_1 identifier_1) {

// Här behandlas undantaget enligt dess typ och villkor.

} Catch (Extraction_type_2 identifier_2) {

// Här behandlas undantaget enligt dess typ och villkor.

}

Fångstsökordet informerar om att koden som omfattas av undantagskontrollen ska behandlas enligt beskrivningen nedan, förutsatt att den matchar dess typ. Identifieraren kan användas inom processkodblocket som argument.

Slutligen

Som det framgår av det föregående kapitlet fångar fångstblock undantag och bearbetar dem. Men mycket ofta finns det en situation när någon kod ska utföras, oavsett om det fanns fel. För detta finns det slutliga sökordet. Det används för att öka värdena på olika räknare, stänga filer eller anslutningar till nätverket.

I det här avsnittet finns flera fångstblock med uppfunna metoder för att fånga undantag. Koden som ingår i försök genererar till exempel en oväntad situation för typen Cold. Då uttrycker "Fånget kallt!" Och "Är det något att heja om?" Kommer att visas i konsolen. Det vill säga slutligen blocket exekveras i vilket fall som helst.

Faktum är att det finns ett sätt att undvika att springa äntligen. Den är relaterad till avslutandet av den virtuella maskinen. Ta reda på hur detta kan göras på Internet.

Kasta sökordet

Kasta kastar ett undantag. Syntaxen ser ut så här:

Kasta nya NewException ();

Här skapas ett nytt undantag med typen NewException (). Som en typ kan du använda klasser som redan ingår i de vanliga Java-biblioteken och definierats tidigare av utvecklaren av din egen produktion.

En sådan konstruktion ingår i beskrivningen av vilken metod som helst, vars samtal måste då inträffa i försöksblocket för att kunna avskilja det.

Nyckelordsslag

Vad man ska göra om man i utvecklingsprocessen finns en situation där metoden kan göra ett undantag, men det går inte att hantera det korrekt. För att göra detta anger metoden signaturen ordet kasta och typen av eventuellt undantag.

Denna etikett är en slags pekare till klientutvecklarna att metoden inte kan bearbeta sitt eget undantag. Dessutom, om fel typen är verifierbar, kommer kompilatorn uttryckligen att ange det.

Prova med resurser

I Java version 7 har utvecklare tagit med sig en så viktig innovation som att bearbeta försöksblocket med resurser.

Många av objekten som skapats i Java, efter användningen, måste stängas för att spara resurser. Tidigare var du tvungen att redogöra för och stoppa sådana fall manuellt. Nu har de ett gränssnitt AutoClosable. Det hjälper till att automatiskt stänga redan använda objekt, placerade i försöksblocket. Tack vare detta tillvägagångssätt blev det bekvämare att skriva koden, dess läsbarhet ökade signifikant.

Anpassade Java-undantagsklasser

Skaparna av det beskrivna programmeringsspråket tog hänsyn till många aspekter vid utformning av typer av oförutsedda situationer. Alla varianter av utfallet av händelser kan emellertid inte förhindras, därför är det i Java möjligt att bestämma sina egna undantag som är lämpliga för behoven hos en viss kod.

Det enklaste sättet att skapa är att ärva från det objekt som är mest lämpligt för sammanhanget.

Här ärvde du från Undantag, en klass som används för att definiera dina egna undantag. I MyException finns det två konstruktörer - en som standard, den andra - med argumentet för msg typ String.

Sedan i offentliga klassen FullConstructors, är metoden f implementerad, vars underskrift innehåller kasta MyException. Detta nyckelord innebär att f kan kasta ett Java-undantag av typen MyException. Vidare, i metoden, skrivs textinformationen till konsolen och den faktiska generationen MyException, vid kasta.

Den andra metoden är något annorlunda än den första genom att när ett undantag kastas, skickas en strängparameter till den som kommer att återspeglas i konsolen när den tas. I huvudsak ser du att f () och g () är placerade i försöksblocket, och fångsordet är inställt för att fånga MyException. Resultatet av behandlingen är resultatet av felmeddelandet till konsolen:

Således var det möjligt att lägga till Java-undantag, skapade med egna händer.

Undantagsarkitektur

Liksom alla objekt i Java är undantag också ärvda och har en hierarkisk struktur. Rotenheten för alla fel som kastas ut i detta programmeringsspråk är java.lang.Throwable-klassen. Det ärar två typer - Fel och Undantag.

Fel - meddelar om kritiska fel och representerar okontrollerade Java-undantag. Avlyssning och behandling av sådana data förekommer i de flesta fall på utvecklingsstadiet och behöver inte genomföras i den slutliga ansökan.

Den vanligaste klassen för att skapa och analysera undantag är Undantag. Vilket är i sin tur uppdelat i flera grenar, inklusive RuntimeException. RuntimeException avser runtime-undantag, det vill säga de som uppstår när programmet körs. Alla klasser som ärvade från det är oförklarliga.

Vanliga undantag

I Java-undantag, vars lista presenteras nedan används oftast, så det är värt att beskriva var och en mer detaljerat:

• ArithmeticException. Detta inkluderar fel relaterade till aritmetiska verksamheter. Det mest slående exemplet är uppdelningen med noll.
• ArrayIndexOutOfBoundsException - tillgång till numret på elementet i matrisen som överstiger dess totala längd.
• ArrayStoreException - ett försök att tilldela ett arrayelement av en inkompatibel typ.
• ClassCastException är ett försök att missförstå en typ till en annan.
• IllegalArgumentException - användning av ett ogiltigt argument i metodanropet.
• NegativeArraySizeException är ett undantag när du skapar en rad negativa storlekar.
• NullPointerException - felaktig användning av nollreferens.
• NumberFormatException - uppstår när strängen inte konverteras till ett nummer.
• UnsupportedOperationException - åtgärden stöds inte.

Dessa exempel är okontrollerade typer av Java-undantag. Och så kolla in:

• ClassNotFoundException - klass ej hittad.
• IllegalAcccessException - begränsar tillgången till klassen.
• AvbrutenException - Avbrott av flödet.
• NoSuchFieldException - det obligatoriska fältet existerar inte.

Tolkning av undantag

Med tanke på gemensamma undantag bör det noteras att deras tolkning under utveckling kan misstas. Därefter finns en liten lista som förklarar mer när en oförutsedd situation kan uppstå.

NullPointerException. Den allra första gången som ett undantag uppstår är att referera till en objektreferens som är null. Detta gäller även metoderna för klassens nollinstans. En NullPointerException kan kastas och om längden på arrayen är lika med null. Undvik sådana situationer genom att regelbundet kontrollera objekt på null.

ArrayIndexOutOfBoundsException. Alla program kan inte existera utan att använda arrayer. Följaktligen kan en frekvent hänvisning till dem ge upphov till fel. Ett undantag uppstår när utvecklaren försöker komma åt ett arrayelement som inte finns i indexlistan. Till exempel är det begärda värdet över längden eller mindre än noll. Det förefaller ofta som ett resultat av att räkningen i arrayen börjar från noll.

rön

Undantagshantering Java är ett kraftfullt miljöverktyg som underlättar programmets arbete och låter honom skapa ren och felfri kod. Utvecklarföretagets status och rykte beror på hur smidig och stabil applikationen fungerar.

Naturligtvis är det i mer eller mindre enkla program mycket lättare att hålla reda på frilanssituationer. Men i stora automatiserade komplex för flera hundra tusen linjer är detta bara möjligt som ett resultat av långfristig debugging och testning.

För Java-undantag, fel som uppstår i vissa applikationer erbjuder enskilda företag belöningar när de är entusiaster. Särskilt uppskattade är de som orsakar kränkning av programvarukomplexets säkerhetspolitik.