Java: uitzonderingen en hun behandeling

Elk programma zal stabiel werken alleen als de broncode wordt opgespoord, en er zijn geen omstandigheden die onvoorziene situaties kan veroorzaken. Het inlopen mogelijke storingen wordt op de programmeringsfase uitgevoerd. Om dit te doen, de ontwikkelaar rekening houdt met alle de verwachte uitkomsten en pogingen om het effect van de fout te beperken, zodat het niet zou kunnen interfereren met de werking van het programma, of leiden tot de ineenstorting.

Wanneer u nodig exception handling

In Java, kan een uitzondering worden veroorzaakt door een onjuiste invoer van de gebruiker, geen behoefte aan een resource of plotselinge verbroken netwerkverbindingen programma. Voor comfortabel gebruik gemaakt door de applicatie-ontwikkelaar, moet u het optreden van noodsituaties te beheersen. De consument moet niet te wachten om een programma te stoppen, om gegevens te verliezen als gevolg van een niet-verwerkte uitzondering, of slechts een deel van een bericht waarin staat dat er iets mis is gegaan.

Omgaan met Java uitzonderingen

Wat te overwegen? De Java-taal heeft zijn eigen ingebouwde exception handling functionaliteit. Natuurlijk is een groot percentage van de fouten gevangen door een ander compilatie fase, zal het systeem automatisch dat het gebruik is het niet langer mogelijk is op de hoogte. Maar er is dit soort uitzondering die optreedt tijdens de uitvoering. De ontwikkelaar moet in staat zijn om het te anticiperen en om de code te ontwerpen zodat het niet een fout veroorzaakte, en verwerkt het op een speciale manier en overhandigd controle naar een ander kantoor.

In Java, wordt deze opgelegd door de compiler om een uitzondering te vangen, zodat de typische problemen zijn bekend en hebben een standaard oefening patronen.

typisch uitsluitingen

Het eenvoudigste voorbeeld, waarin je een uitzondering kunt krijgen - deze divisie. Ondanks zijn eenvoud, wat als een deler, nul kan zijn, wat zal resulteren in een fout. Nou, als het mogelijk is om de opkomst van het verleden te voorspellen en te voorkomen. Maar deze optie is niet altijd beschikbaar, zodat de uitzondering vangen moeten rechtstreeks in het geval van "verdeel door nul" worden georganiseerd.

Het Java-mechanisme om de verwerking fout onderscheppen ziet er als volgt uit:

• heap uitzonderingsobject wordt gemaakt, alsmede alle andere;
• de natuurlijke loop van het programma wordt onderbroken;
• uitsluiting mechanisme probeert een alternatieve manier om de code te blijven vinden;
• Zoek een veilige uitvoering van het programma in de processor, het werk of hersteld, of zullen realisatie van uitzondering plaatsvinden op een speciale manier.

Het eenvoudigste voorbeeld van het creëren van een fout kan er zo uitzien:

if (a == null)

werpen een nieuw NullPointerException ();

Hier wordt de variabele een gecontroleerd bij initialisatie, dat wil zeggen, niet of de verwijzing naar een null object. Als deze situatie is ontstaan en moeten een speciale behandeling, wordt een uitzondering gegenereerd door een worp nieuwe NullPointerException ().

Weinig details over zoekwoorden

Bij het omgaan met uitzonderingen is vaak nodig om de keyword Java te gebruiken om te verwijzen naar een bepaalde actie. Deze taal van hun vijf programmering:

• Proberen. Dit zoekwoord al ontmoet, en het betekent een overgang naar een verzameling code die een uitzondering kan gooien. Block beperkte accolades {}.
• Catch. Het onderschept de gewenste uitzondering en te hanteren op gepaste wijze.
• Eindelijk. Dit zoekwoord is optioneel en wordt gebruikt om een bepaald stuk code, die hoe dan ook nodig is uit te voeren, zelfs als er geen uitzondering niet wordt gevangen. direct toegevoegd na het blok try.
• Gooi - kunt u Java uitzonderingen maken vanaf elke locatie.
• Gooit - een zoekwoord dat is geplaatst in de methode handtekening. Het betekent dat de volgende code een uitzondering van dit type Java kan gooien. Deze markering dient als een signaal aan ontwikkelaars die moeten worden bedacht - de methode niet kan werken zoals verwacht van hem.

Het vangen met een try

Laat los om Java uitzonderingen, veronderstelt natuurlijk dat het op een speciale manier worden behandeld. De gemakkelijkste manier om dit te doen, als de codelijst wordt omheind in een blok. Die kan een uitzondering bevatten. Wanneer u deze code uitvoert, zal de virtuele machine een onverwachte situatie te vinden, begrijpen dat er een kritische blok en de besturing over naar het station met de verwerking.

De Java-code is verpakt in een speciaal blok try, waarin een uitzondering kan zijn. Zo plaatste hij een aantal onvoorziene situaties die zullen worden gevangen op dezelfde plaats, niet raspolzayas code.

De meest kenmerkende code naar de verwerkingseenheid is als volgt:

try {

// Hier is één of andere code die een uitzondering kunnen genereren

} Vangst (Tip_isklyucheniya_1 identifikator_1) {

// Hier is er exception handling, afhankelijk van type en voorwaarden;

} Vangst (Tip_isklyucheniya_2 identifikator_2) {

// Hier is er exception handling, afhankelijk van type en voorwaarden;

}

Zoekwoord catch meldt dat code en scannen een uitzondering, worden behandeld zoals hieronder beschreven, op voorwaarde dat het voldoet aan het type. Het identificatiemiddel kan worden gebruikt bij het verwerken van het codeblok als argumenten.

eindelijk

Zoals uit het vorige hoofdstuk duidelijk werd, catch-blokken te vangen uitzonderingen en te verwerken. Maar heel vaak de situatie zich voordoet waar moet wat code uit te voeren, ongeacht of ze werden gevangen fouten. Hiervoor is het sleutelwoord eindelijk. Het wordt gebruikt om de waarden van de verschillende tellers te verhogen, het sluiten van bestanden of netwerkverbindingen.

Deze plot geeft meerdere blokken catch uitgevonden methoden te vangen uitzonderingen. Bijvoorbeeld, de code die in de try genereert een onverwachte situatie, zoals Cold. Dan zal de console worden weergegeven uitdrukking «Gevangen koud!» En «Is dat iets om te juichen?». Dat wil zeggen, het blok finally wordt uitgevoerd in ieder geval.

In feite is een manier om te voorkomen triggering eindelijk daar. Het is verbonden met de voltooiing van de virtuele machine. Vinden hoe het te implementeren, is het mogelijk op het internet open ruimten.

throw trefwoord

Throw genereert een uitzondering. De syntax is als volgt:

werpen een nieuw NewException ();

Er wordt een nieuwe uitzondering op het type NewException (). Als een type kan worden gebruikt reeds is opgenomen in de standaard Java-bibliotheek klassen en eerder door de ontwikkelaar van de eigen productie.

Dit ontwerp maakt deel uit van de beschrijving van elke methode, die de oproep vervolgens dient binnen het blok try, om te kunnen onderscheppen.

keyword gooit

Wat gebeurt er als in het proces van de ontwikkeling van een situatie waarin de methode een uitzondering kan gooien, maar zijn niet in staat om goed te behandelen. Daartoe in de signatuur methode beschrijft het woord worpen en type uitzonderingsgevallen.

Dit label is een soort indicator voor client-ontwikkelaars dat de methode niet in staat om hun zelfde uitzondering te behandelen. Bovendien, als het type fout wordt gecontroleerd, dan zal de compiler expliciet dwingen om vragen.

Probeer om de middelen

De Java-versie 7 ontwikkelaars hebben een belangrijke innovatie, als een behandeling blok try met middelen inbegrepen.

Veel objecten worden gemaakt in Java, na gebruik moet worden afgesloten om hulpbronnen te beschermen. Voorheen moest hiermee rekening te houden en deze gevallen handmatig te stoppen. Nu echter, verscheen ze AutoClosable interface. Het helpt om reeds gebruikte voorwerpen geplaatst in een blok try automatisch sluiten. Door deze aanpak het gemakkelijker is geworden om code te schrijven in de leesbaarheid aanzienlijk wordt verhoogd.

Eigen klassen Java uitzonderingen

De makers van de beschreven programmeertaal werd rekening gehouden met vele aspecten van de soorten vormgeving van noodsituaties. Echter, alle van de opties om te voorkomen dat de uitkomst van de gebeurtenissen zal niet werken, dus in Java de mogelijkheid om hun eigen uitzonderingen definiëren geïmplementeerd, is aangepast aan de behoeften van de bepaalde code.

De eenvoudigste manier om te creëren - te erven van de meest geschikte om het object context.

Er is er gebeurd met erven van Exception, de klasse die wordt gebruikt om uw eigen uitzonderingen definiëren. In MyException heeft twee constructeurs - een default, de tweede - met het argument msg String.

Daarna, in de publieke klas FullConstructors geïmplementeerde werkwijze f, waarop de handtekening bevat gooit MyException. Dit sleutelwoord betekent dat f kan gooien als Java MyException uitzondering. Verder wordt in de werkwijze lichaam geproduceerd tekstinformatie toegevoerd aan de console zelf en de feitelijke opwekking MyException door gooien.

De tweede methode is iets anders dan het eerste dat wanneer u een uitzondering maakt, wordt het voorbij een string parameter, die zal worden weerspiegeld in de console op te vangen. In de belangrijkste blijkt dat f () en g () worden in een poging controle gebracht en keyword vangst geconfigureerd MyException vangen. Het resultaat van de verwerking is om een foutmelding aan de console weer te geven:

Zo kwam naar Java uitzonderingen toe te voegen, door zijn eigen hand.

architectuur uitzonderingen

Zoals met alle objecten in Java, zijn uitzonderingen ook geërfd en hebben een hiërarchische structuur. Het hoofdelement van alle fouten gegooid in deze programmeertaal is klasse java.lang.Throwable. Overgenomen van hem twee soorten - Error en Exception.

Fout - signaleert de kritieke fout en is uitgeschakeld Java uitzonderingen. Afluisteren en verwerken dergelijke gegevens in de meeste gevallen treedt in het ontwerpstadium en niet moet inbrengen in de uiteindelijke toepassingscode.

De meest gebruikte klasse voor het maken en analyseren van de uitzonderingen is Exception. Die op zijn beurt, is verdeeld in verschillende branches, waaronder RuntimeException. Door RuntimeException zijn runtime uitzonderingen, dat wil zeggen, die zich tijdens het programma. Alle klassen ontleend zijn niet te verifiëren.

Vaak zijn er uitzonderingen

In Java uitzonderingen, is waarvan de lijst hieronder weergegeven, worden het meest gebruikt, zodat je elk van hen in detail moet beschrijven:

• ArithmeticException. Deze omvatten fouten in verband met rekenkundige bewerkingen. De oog springende voorbeeld - de deling door nul.
• ArrayIndexOutOfBoundsException - een beroep op het array-element nummer dat het totaal van de lengte overschrijdt.
• ArrayStoreException - poging om een incompatibele elementtype van de matrix toe.
• ClassCastException - een poging om de verkeerde type naar het andere te brengen.
• IllegalArgumentException - gebruik van de verkeerde argument in de methode.
• NegativeArraySizeException - een uitzondering wanneer u een reeks van negatieve grootte aan te maken.
• NullPointerException - misbruik van verwijzingen naar de null.
• NumberFormatException - vindt plaats wanneer een verkeerde snaar conversie naar integer.
• UnsupportedOperationException - wordt niet ondersteund.

Deze voorbeelden geven de soorten ongecontroleerde Java uitzonderingen. Maar dus kijk gecontroleerd:

• ClassNotFoundException - Klasse niet gevonden.
• IllegalAcccessException - beperken de toegang tot de klas.
• InterruptedException - onderbreking van de stroom.
• NoSuchFieldException - er zijn geen verplicht veld.

De interpretatie van de uitzonderingen

Spreken van vaak voorkomende uitzonderingen moet worden opgemerkt dat de interpretatie ervan in het ontwerp, kan verkeerd worden opgevat. Next is een korte lijst uit te leggen in meer detail, waar er een onverwachte situatie kan zijn.

NullPointerException. Het eerste geval wanneer er een uitzondering is beroep op een verwijzing naar een object dat gelijk is aan nul is. Het omvat ook de nul klasse instantiemethoden. NullPointerException worden gegooid bij het verkrijgen van een gelijke lengte nul array. Om dergelijke situaties te voorkomen controleert regelmatig sites op de nul.

ArrayIndexOutOfBoundsException. Elk programma kan niet bestaan zonder het gebruik van arrays. Dienovereenkomstig kan het frequente gebruik te genereren en fouten. Uitzondering optreedt wanneer een ontwikkelaar probeert om een array-element dat niet in de indexlijst. Bijvoorbeeld, de gewenste waarde boven of onder nul lengte. Vaak is een gevolg van het feit dat de reeks begint met een score van nul.

bevindingen

Omgaan met Java uitzonderingen na - een krachtig hulpmiddel omgeving, die sterk vergemakkelijkt het werk van de programmeur en kan hij een schoon en vrij van fouten in de code te creëren. Over hoe soepel en stabiel functioneren toepassing is afhankelijk van de status en reputatie van de ontwikkelaar.

Natuurlijk, in een min of meer eenvoudige programma's om abnormale situaties veel gemakkelijker te traceren. Maar in grote geautomatiseerde complexen een paar honderd duizend regels is het mogelijk uitsluitend het resultaat van langdurige testen en debuggen.

Voor Java uitzondering fout uit die zich voordoen bij sommige toepassingen, sommige bedrijven bieden een beloning als ze liefhebbers vinden. Vooral gewaardeerd door degenen die een schending van het beveiligingsbeleid software veroorzaken.