Afhandeling van uitzonderingen in Java

Alle programma's zijn gevoelig voor fouten, dit is onvermijdelijk, want hoeveel we het ook geven, er kan altijd iets gebeuren dat de stroom van onze applicatie verbreekt. Wanneer er een fout optreedt, moeten we de meest elegante manier vinden om de gebruiker te laten weten zonder de privé informatie over onze omgeving.
Voor deze gevallen hebben we de uitzonderingenDit zijn objecten die worden gebouwd en gegenereerd wanneer er een fout optreedt die de normale werking van de applicatie verhindert, dit geeft ons de mogelijkheid om het af te handelen en te voorkomen dat het programma onverwacht eindigt, waardoor we een elegantere boodschap aan de gebruikersnaam kunnen geven.
Zoals we de . aangeven uitzonderingen Het zijn objecten die worden gegenereerd wanneer er een fout optreedt in de uitvoering van ons programma, als we ze niet goed afhandelen, zal het onverwacht eindigen met de fout waarvoor het is mislukt.
Afhandeling van uitzonderingenOm dit te beheersen, moeten we de uitzondering afhandelen, dit houdt in dat het object wordt vastgelegd en een specifieke instructie wordt uitgevoerd, hiervoor hebben we een structuur in Java het blok genoemd probeer {} catch (type uitzondering) {} waarmee we een instructie kunnen evalueren en als er een uitzondering optreedt, vangen en een alternatieve code uitvoeren.
Er zijn ook gevallen waarin wij degenen zijn die vrijwillig de uitzondering moeten opheffen, hetzij als onderdeel van een programmafoutopsporing of omdat we binnen onze ontwikkelingslogica een uitzondering willen maken als een combinatie van voorwaarden optreedt, hiervoor hebben we de methode gooien () die uit het Engels komt om te gooien.
Laten we hieronder de volledige structuur bekijken die we kunnen gebruiken om het bovengenoemde in de praktijk te brengen:

 try {// hier is de code om te proberen uit te voeren // hier kunnen we een uitzondering gooien met de throw-methode van willen} catch (typeException ex) {// zodra de uitzondering is gevangen, is hier de code die zal blijven lopen } 

Zoals we zien, impliceert de structuur niets dat we niet kunnen begrijpen, laten we eens kijken naar een meer diepgaand voorbeeld.
We gaan nu een programma maken dat de deling van twee gehele getallen doet, zoals we zouden moeten weten, als we een geheel getal delen door nul 0 zal er een fout optreden, in dit geval een uitzondering van het rekenkundige type, die we gaan vangen en voorkomen dat ons programma vreselijk faalt. Laten we de te gebruiken code bekijken:

 java.util.Scanner importeren; public class DivisionException {public static int quotient (int number1, int number2) {if (number2 == 0) gooi nieuwe ArithmeticException ("De deler kan niet 0 zijn"); retour nummer1 / nummer2; } public static void main (String [] args) {Scannerinvoer = nieuwe scanner (System.in); System.out.println ("Voer twee gehele getallen in:"); int nummer1 = invoer.nextInt (); int nummer2 = invoer.nextInt (); probeer {int resultaat = quotiënt (getal1, getal2); System.out.println (nummer1 + "/" + nummer2 + "is" + resultaat); } catch (ArithmeticException ex) {System.out.println ("Uitzondering: een geheel getal" + "kan niet worden gedeeld door 0"); } System.out.println ("Hier is ons programma"); }} 

We merken dat de uitzondering wordt gegenereerd met de methode gooien binnen een aangepaste methode die de deling van de gehele getallen doet, dan noemen we deze methode in onze probeer blok en ten slotte, als de uitzondering optreedt, vangen we deze op en vertonen we de nodige fout en kunnen we doorgaan met ons programma. Laten we eens kijken hoe het eruit ziet op onze console:

VERGROTEN

Hiermee beëindigen we onze tutorial die effectief heeft aangetoond hoe we uitzonderingen op een eenvoudige manier kunnen behandelen, waardoor een fatale fout wordt vermeden die de stroom van ons programma vernietigt.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven