try catch finally
In deze zelfstudie bespreken we verschillende trefwoorden die in Java worden gebruikt voor het afhandelen van uitzonderingen, zoals Try, Catch, Final, Throw en Throws met voorbeelden:
In onze vorige tutorials hebben we de basisprincipes van het afhandelen van uitzonderingen in Java gezien, samen met de verschillende uitzonderingen die worden ondersteund door de Java Exception-klasse. We hebben ook de NullPointerException in detail besproken.
We kunnen uitzonderingen in ons programma opnemen door bepaalde sleutelwoorden te gebruiken die in Java worden aangeboden. Deze sleutelwoorden definiëren verschillende codeblokken die het definiëren en afhandelen van uitzonderingen vergemakkelijken.
Bezoek hier voor de exclusieve Java Training Tutorial Series.
Wat je leert:
Probeer, vang, eindelijk in Java
De onderstaande trefwoorden worden in Java gebruikt voor het afhandelen van uitzonderingen.
- Proberen
- Vangst
- Tenslotte
- Werpen
- Gooit
In de volgende tabel worden deze sleutelwoorden kort beschreven.
Trefwoord | Omschrijving |
---|---|
Proberen | We specificeren het codeblok dat aanleiding zou kunnen geven tot de uitzondering in een speciaal blok met het trefwoord 'Try'. |
Vangst | Als de uitzondering wordt gemaakt, moet deze door het programma worden opgevangen. Dit wordt gedaan met behulp van een 'catch' -woord. Dus een catch-blok volgt het try-blok dat een uitzondering oproept. Het trefwoord catch moet altijd worden gebruikt bij een poging. |
Tenslotte | Soms hebben we een belangrijke code in ons programma die moet worden uitgevoerd, ongeacht of de uitzondering wordt gegenereerd. Deze code wordt in een speciaal blok geplaatst dat begint met het trefwoord 'Eindelijk'. Het blok Eindelijk volgt het blok Try-catch. |
Werpen | Het sleutelwoord 'gooien' wordt gebruikt om de uitzondering expliciet te genereren. |
Gooit | Het sleutelwoord 'Throws' genereert geen uitzondering, maar wordt gebruikt om uitzonderingen aan te geven. Dit sleutelwoord wordt gebruikt om aan te geven dat er een uitzondering kan optreden in het programma of de methode. |
In deze tutorial zullen we alle bovenstaande sleutelwoorden in detail bespreken, samen met de programmeervoorbeelden.
Probeer Blokkeren in Java
Elke keer dat we een programma schrijven, kan er een code zijn waarvan we vermoeden dat deze een uitzondering genereert. Bijvoorbeeld, we zouden kunnen vermoeden dat er een 'delen door nul' -bewerking in de code zit die een uitzondering zal genereren.
Deze code die een uitzondering kan veroorzaken, wordt ingesloten in een blok met het sleutelwoord 'proberen'. Het try-blok bevat dus de code of een reeks instructies die een uitzondering kunnen veroorzaken.
De algemene syntaxis van het try-blok is als volgt:
Dus als een programmeur denkt dat bepaalde uitspraken uitzonderingen opleveren, plaats deze uitspraken dan in een try-blok. Merk op dat wanneer een uitzondering optreedt bij een specifieke instructie in een try-blok, de rest van de code niet wordt uitgevoerd.
Wanneer een uitzondering optreedt in een try-blok bij een bepaalde instructie, komt de controle naar buiten en wordt het programma abrupt beëindigd. Om deze abrupte beëindiging van het programma te voorkomen, moeten we deze uitzondering “afhandelen”. Deze afhandeling wordt gedaan met behulp van het trefwoord 'catch'. Dus een try-blok heeft altijd een catch-blok dat erop volgt.
Catch Block in Java
We gebruiken een catch-blok om uitzonderingen af te handelen. Dit is het blok met het trefwoord 'catch'. Het catch-blok volgt het try-blok.
Telkens wanneer een uitzondering optreedt in het try-blok, wordt de code in het catch-blok die overeenkomt met de uitzondering uitgevoerd.
De algemene syntaxis van het catch-blok is:
Over het algemeen moet de gedeclareerde uitzondering de bovenliggende klasse van alle uitzonderingen zijn, d.w.z. Uitzondering. Maar als er meer dan één uitzondering is, kunnen we ook specifieke uitzonderingstypen of gegenereerde uitzonderingen schrijven.
Vervolgens bespreken we het try-catch-blok. Merk op dat we voor elk try-blok meerdere catch-blokken kunnen hebben.
Probeer Java te vangen
De algemene syntaxis van het try-catch-blok wordt hieronder weergegeven:
Het try-blok kan meerdere regels code hebben die meerdere uitzonderingen kunnen veroorzaken. Elk van deze uitzonderingen wordt afgehandeld door een onafhankelijk catch-blok.
De generieke uitzonderingshandler, object e van de Exception-klasse, kan alle uitzonderingen afhandelen, maar als we specifieke uitzonderingen willen afhandelen, is het raadzaam om de generieke exception-handler op te geven als het laatste catch-blok.
Java Probeer Catch-voorbeeld
Laten we nu een try-catch-blok in Java demonstreren. Hier in het try-blok definiëren we een deeloperatie. De deler is nul. Dus de bewering die de twee getallen verdeelt, roept een rekenkundige uitzondering op. We hebben een catch-blok dat een handler definieert voor een rekenkundige uitzondering.
Hieronder is een voorbeeld Java-programma gegeven.
Uitvoer
salesforce admin interviewvragen en antwoorden voor ervaren
Meerdere uitzonderingen opvangen
Zoals eerder vermeld, kan een try-blok een code bevatten die meer dan één uitzondering oplevert. In dit geval hebben we meer dan één catch-blok nodig om elke uitzondering af te handelen. Een enkel try-blok kan worden gevolgd door meerdere catch-blokken. Elk catch-blok zal de onafhankelijke uitzonderingen afhandelen.
In het geval van meerdere catch-blokken, moeten we de onderstaande punten onthouden:
- In een Java-programma kan op elk moment slechts één uitzondering optreden. Bovendien wordt er op elk moment slechts één catch-blok uitgevoerd.
- De meerdere catch-blokken moeten zo worden geordend dat het catch-blok voor de meest specifieke uitzondering eerst komt en vervolgens het algemene.
Bijvoorbeeld, als we ArithmeticException en algemene uitzondering hebben, dan komt de catch-blokafhandeling ArithmeticException eerst, gevolgd door de catch-blokafhandeling Uitzondering.
Het onderstaande voorbeeld laat meerdere catch-blokken zien.
Uitvoer
In het bovenstaande programma wordt een ArithmeticException opgeworpen die wordt opgevangen in het eerste catch-blok. Als dit catch-blok niet was gespecificeerd, zou de uitzondering zijn doorgevoerd naar het gegeneraliseerde catch-blok.
Laten we het bovenstaande programma enigszins aanpassen, zodat het try-blok twee uitzonderingen oplevert. Laten we nu de output bekijken.
Uitvoer
Als we deze uitvoer zien, wordt ArrayIndexOutOfBoundsException weergegeven. Dit komt doordat de instructie die ArrayIndexOutOfBoundsException oproept, eerst wordt uitgevoerd. De uitzondering wordt gegenereerd en het besturingselement gaat naar het overeenkomstige catch-blok.
Geneste Try-Catch
Een try-blok binnen een ander try-blok wordt een genest try-blok genoemd. We hebben dergelijke structuren nodig in bepaalde situaties wanneer een stuk code in een try-code zodanig kan zijn dat sommige regels bepaalde uitzonderingen opwerpen en een ander stuk code een heel andere uitzondering oproept.
In het geval van geneste try-blokken, wordt eerst het binnenste try-blok uitgevoerd en wordt de exception afgehandeld. Als het binnenste try-blok geen overeenkomend catch-blok heeft, wordt het een niveau voortgeplant tot aan het bovenliggende try-blok. Op deze manier wordt de uitzondering naar boven gepropageerd totdat een overeenkomende uitzonderingshandler wordt gevonden.
Als er geen exception-handler is die overeenkomt met de uitzondering, wordt het programma abrupt beëindigd met een door het systeem gegenereerd bericht.
De algemene syntaxis van een genest try-blok wordt hieronder gegeven:
Laten we een programma implementeren om het geneste try-catch-blok te demonstreren.
Uitvoer
In het bovenstaande programma hebben we twee try-blokken ingesloten in het belangrijkste try-blok. Beide innerlijke try-blokken hebben een code die ArithmeticException oproept. Maar we hebben alleen een bijpassend catch-blok voorzien voor het eerste blok en niet voor het tweede try-blok.
Daarom propageert het tweede blok zijn uitzondering naar het belangrijkste try-blok en verwerkt het vervolgens. Dit blijkt uit de output.
Eindelijk blokkeren in Java
Tot nu toe hebben we het try-catch- en geneste try-blok gezien. We weten dat de code die naar verwachting de uitzondering oproept, in een try-blok wordt geplaatst. Als er een uitzondering optreedt, wordt de rest van de code in het try-blok niet uitgevoerd.
Het programma wordt ofwel abrupt beëindigd als een uitzondering niet wordt afgehandeld, ofwel het besturingselement wordt doorgegeven aan de uitzonderingshandler.
In een dergelijke situatie ontstaat de behoefte om een code op te nemen die moet worden uitgevoerd ongeacht of er een uitzondering optreedt of niet. Dit betekent dat we een stuk code zullen uitvoeren, zelfs als er een uitzondering optreedt en ook als de uitzondering niet optreedt.
Maar aangezien het try-blok wordt afgesloten nadat de uitzondering is gegenereerd, kunnen we deze code niet in het try-blok plaatsen. Op dezelfde manier heeft catch block een exception handler, dus we kunnen deze niet ook in het catch block plaatsen.
We hebben dus een apart blok nodig dat een code bevat die wordt uitgevoerd ongeacht of er een uitzondering optreedt of niet. Java biedt een 'eindelijk' -blok dat dit stuk code bevat.
Daarom kan een final block in Java kritische statements bevatten die in het programma moeten worden uitgevoerd. De uitvoering van deze instructies moet worden uitgevoerd, zelfs als er al dan niet een uitzondering optreedt.
Daarom zullen we code zoals het sluiten van verbindingen, stroomobjecten, enz. Of enige opschoningscode in het slotblok plaatsen, zodat ze kunnen worden uitgevoerd, zelfs als er een uitzondering optreedt.
Het uiteindelijke blok in Java wordt meestal na een try of catch-blok geplaatst. Merk op dat het final block niet kan bestaan zonder een try block. Wanneer het laatste blok wordt opgenomen in de try-catch, wordt het een ' probeer-vangst-eindelijk ”Blok.
We kunnen het laatste blok in de code voor het afhandelen van uitzonderingen overslaan. Dit betekent dat tenslotte blokkeren optioneel is.
Als het try-blok geen uitzondering oplevert, wordt het final block uitgevoerd na het try-blok. Als er een uitzondering is in het try-blok, gaat de besturing eerst over naar het catch-blok en vervolgens naar het laatste blok.
Een uitzondering die optreedt in tenslotte, gedraagt zich op dezelfde manier als elke andere uitzondering. Zelfs als het try-blok een return-statement of branching-statements zoals break and continue bevat, wordt het final-blok nog steeds uitgevoerd.
Met deze punten in gedachten, gaan we door met de algemene syntaxis en voorbeelden van eindelijk blokkeren.
De algemene syntaxis van het laatste blok is als volgt:
Hoewel uiteindelijk blokkeren altijd wordt uitgevoerd, zijn er bepaalde situaties of gevallen waarin het niet wordt uitgevoerd.
Dit zijn de onderstaande gevallen:
- Als de draad dood is.
- Wanneer de methode System.exit () wordt gebruikt.
- Wanneer er een uitzondering optreedt in het laatste blok.
Laten we een paar programma's implementeren om de uiteindelijke blokkering te demonstreren.
Uitvoer
Het bovenstaande programma toont een try-catch-final-blok. In het try-blok wordt een geldige bewerking uitgevoerd en daarom wordt er geen uitzondering gegenereerd. Daarom wordt de controle niet doorgegeven om te proberen, maar om uiteindelijk te blokkeren.
Het volgende programma is een ander voorbeeld van een try-catch-final-blok, maar in dit geval wordt de uitzondering in het try-blok gegooid terwijl we een deling door nul-bewerking uitvoeren. Dus het laatste blok wordt uitgevoerd nadat de try het vangblok is uitgevoerd.
Uitvoer
Gooi een uitzondering in Java
Java biedt een trefwoord 'throw' waarmee we de uitzonderingen expliciet in de code kunnen gooien. Bijvoorbeeld, als we rekenkundige bewerkingen controleren en enkele uitzonderingen willen maken na het controleren van operanden, kunnen we dat doen met het trefwoord ‘throw’.
Met behulp van het throw-sleutelwoord kunnen we de aangevinkte of niet-gecontroleerde uitzonderingen gooien. Het worp-sleutelwoord wordt ook gebruikt om aangepaste uitzonderingen te gooien.
De algemene syntaxis van het throw-sleutelwoord is:
Hieronder is een voorbeeldprogramma gegeven om het throw-sleutelwoord te demonstreren.
Uitvoer
In het bovenstaande programma gebruiken we een methode om leeftijd te valideren. Als de leeftijd is<18, then an exception is thrown to indicate the age is not valid.
Gooit clausule
We hebben geprobeerd te blokkeren om uitzonderingen te declareren. Het bevat de code die tot uitzonderingen kan leiden. Er is een andere manier om een uitzondering te declareren en dit is door het trefwoord 'throws' te gebruiken.
De uitzonderingsverklaring met behulp van het 'throws' sleutelwoord vertelt de programmeur dat er een uitzondering gespecificeerd kan zijn na het 'throws' sleutelwoord en de programmeur moet de corresponderende handlercode voor deze uitzondering opgeven om de normale stroom van het programma te behouden.
De vraag rijst echter waarom we een 'worp'-sleutelwoord nodig hebben als we een betrouwbaarder try-catch-blok hebben om uitzonderingen te declareren en af te handelen?
Een reden is dat het aantal uitzonderingen dat mogelijk kan optreden toeneemt, het aantal catch-blokken dat uitzonderingen afhandelt ook toeneemt, aangezien één catch-blok slechts één uitzondering kan verwerken.
Evenzo, als er veel methoden in een programma zijn en elke methode talloze uitzonderingen heeft, wordt de code onnodig lang en onhandelbaar.
Dus het declareren van een uitzondering met het throws-sleutelwoord in de methodehandtekening en vervolgens het afhandelen van de methodeaanroep met try-catch lijkt een haalbare oplossing.
Een ander voordeel van het declareren van uitzonderingen met het worp-trefwoord is dat we gedwongen zijn om met de uitzonderingen om te gaan. Als we geen handler bieden voor een gedeclareerde uitzondering, zal het programma een foutmelding geven.
De algemene syntaxis van het worp-sleutelwoord is als volgt:
Laten we nu een Java-programma implementeren om het trefwoord 'worpen' te demonstreren.
In dit programma hebben we een klasse Example_throw waarin we een methode testMethod hebben. In de ondertekening van deze testMethod verklaren we twee uitzonderingen IOException en Arithmetic Exception met behulp van het worp-sleutelwoord. Vervolgens worden in de hoofdfunctie de gegooide uitzonderingen afgehandeld door het catch-blok.
Uitvoer
Veel Gestelde Vragen
V # 1) Wanneer worpen throw versus try-catch in Java gebruiken?
Antwoord: Het sleutelwoord 'worpen' wordt gebruikt om de uitzondering aan te geven met de methodehandtekening. Het throw-sleutelwoord wordt gebruikt om de uitzondering expliciet te genereren. Het try-catch-blok wordt gebruikt om de uitzonderingen af te handelen die door anderen worden gegenereerd.
Vraag 2) Kunnen we worpen gebruiken, proberen en vangen in een enkele methode?
Antwoord: Nee. Je kunt de uitzondering niet gooien en deze ook op dezelfde manier vangen. De uitzondering die wordt gedeclareerd met worpen, moet worden afgehandeld in de aanroepende methode die de methode aanroept die de uitzondering heeft veroorzaakt.
V # 3) Wat gebeurt er als een catch-blok een exception genereert?
Antwoord: Als er een uitzondering in het catch-blok wordt gegooid, stopt het programma de uitvoering. Als het programma moet doorgaan, dan moet er een apart try-catch-blok zijn om de uitzondering die in het catch-blok is opgeworpen af te handelen.
V # 4) Wat is try-catch-eindelijk in Java?
Antwoord: Het try-catch-final-blok bevat de drie blokken, d.w.z. try-block, catch-block en tenslotte block.
Try block bevat de code die een uitzondering kan genereren. Catch block bevat de exception handler voor uitzonderingen in het try block. Het laatste blok bevat de kritieke code die wordt uitgevoerd ongeacht of de uitzondering is opgetreden of niet.
wat is de beste YouTube-videoconvertor
V # 5) Kan het blok eindelijk een try-catch hebben?
Antwoord: Ja, als we een opschoningscode hebben die een uitzondering in het blok kan veroorzaken, dan kunnen we een blok proberen te vangen. Het ziet er echter lelijk uit.
Gevolgtrekking
In deze tutorial hebben we de verschillende trefwoorden besproken die worden gebruikt bij het afhandelen van uitzonderingen in Java. We hebben de sleutelwoorden zoals proberen, vangen, ten slotte, gooien en gooien besproken.
De code die mogelijk een uitzondering genereert, is ingesloten in het try-blok en catch levert de handler voor de uitzondering. Het laatste blok voert de code uit die erin is ingesloten, ongeacht of de uitzondering wordt gegenereerd of niet. Het laatste blok volgt over het algemeen het try of try-catch-blok.
We gebruiken het trefwoord throws om uitzonderingen aan te geven met de methode signature en throw wordt expliciet gebruikt om uitzonderingen te genereren. We gebruiken meestal het throw-trefwoord om aangepaste uitzonderingen te genereren.
Bekijk hier de perfecte Java-trainingsgids.
Aanbevolen literatuur
- Java-uitzonderingen en het afhandelen van uitzonderingen met voorbeelden
- Hoe om te gaan met de ArrayIndexOutOfBoundsException in Java?
- JAVA-zelfstudie voor beginners: 100+ praktische Java-videotutorials
- Afhandeling van JDBC-uitzonderingen - Hoe om te gaan met SQL-uitzonderingen
- C # Tutorial voor het afhandelen van uitzonderingen met codevoorbeelden
- Volledige gids voor het omgaan met PL SQL-uitzonderingen met voorbeelden
- Afhandeling van uitzonderingen in C ++
- Python Try Behalve - Python Handling Exception met voorbeelden