Hvordan kaste unntak i Java

Et unntak er en potensiell feil, hvor Java -systemet signaliserer Java -programmet. Hvis unntaket (feil) ikke blir håndtert, vil den aktuelle tråden slutte å operere. Hvis programmet ble enkelttrådet, ville programmet slutte å operere. Tenk på følgende program: Public Class theClass
public static void main (String [] args)
System.ute.println ("sett 1");
int teller = 6;
int nevner = 0;
int kvotient = teller / nevner;
System.ute.println ("sett 2");
System.ute.println (kvotient);

Dette programmet prøver å dele opp med 0 ved den fjerde uttalelsen i Main () -metoden. I matematikk skal ikke noe tall deles med 0. Datamaskiner tillater heller ikke dette. Dette programmet skal skrive ut “Sett 1”, så hvis Division med null er mulig av datamaskinen, skal programmet skrive ut “Seen 2” og deretter skrive ut kvoten til 6 delt med null.

Dette programmet er sammensatt av Javac -kompilatoren. Imidlertid, når programmet drives av Java Virtual Machine (operativsystem), er "sett 1" skrives ut, og programmet stopper ved den fjerde uttalelsen, hvor divisjon med null forventes, hvorfra (hvor og da) er en feilmelding er utstedt (vist). Programmet slutter å utføre ved divisjonserklæringen med null, skriver ut en feilmelding og slutter å operere. Etter det blir de to siste uttalelsene ikke utført (ikke opererer).

Imidlertid, hvis dette var multiplikasjon med null, som er tillatt, ville de to siste uttalelsene blitt utført. Denne artikkelen gir det grunnleggende om å kaste og håndtere et unntak i Java.

Håndteringsfeil

Med Java er det mulig å håndtere en feil, som deling med null, med enkel kode; slik at utsagnene (koding) etter feilen skal fungere (utføres). Hva er feilen her? - Feilen her er divisjon for null. Koden (løsningen) av programmereren skal ikke la feilen finne sted. Programmereren må kode det som kalles feilen, som er et nytt unntaksobjekt. Unntaksobjektet må bli fanget. Når unntaksobjektet blir fanget, må programmet komme seg etter det. Gjenoppretting av en feil betyr å håndtere unntaket.

Unntaksklassen håndterer feilen mer enn programmereren. Unntaksklassen trenger ikke å importeres i begynnelsen av programmet. Denne importen gjøres automatisk, uten hjelp fra programmereren.

Unntaksklassen

Det er to hovedfeilhåndteringsklasser i Java: unntaksklassen og feilklassen. Denne artikkelen omhandler bare unntaksklassen. Som karakter kjenner unntaksklassen ordinære feil, for eksempel divisjon for null og uønskede nullverdier i en bokstavelig streng.

Når et nytt unntaksobjekt kastes, like etter uttalelsen som vil resultere i en feil, vil unntaksklassebiblioteket vite feilen; Hvis det er en vanlig feil. Unntaksklassen trenger ikke å importeres i begynnelsen av programmet. Denne importen gjøres automatisk, uten hjelp fra programmereren.

Java Try -uttalelsen

Try-uttalelsen er en sammensatt uttalelse, bestående av prøveblokken og en fangstblokk. I forenklet form er syntaks:

prøv
//problemstilling;
Kast nytt unntak ();
* uttalelser hvis ingen feil oppstår *

fangst (unntak e)
System.ute.println ("unntaksmelding:" + e.getMessage ());

prøve er et reservert ord; Fangst er et reservert ord. Try-blokken har problemstilling. En uttalelse som,

int kvotient = teller / nevner;

er en problemstilling. Hvis nevneren ikke er null, oppstår ingen feil. Hvis nevneren er null, er det en feil. Kastuttalelsen vil vanligvis være,

Kast nytt unntak ();

Denne kastuttalelsen skal komme umiddelbart etter problemstillingen. Hvis det oppstår en feil, kaster kastuttalelsen et nytt unntaksobjekt. Legg merke til parentesene. Hvis nevneren er 0, blir et nytt unntaksobjekt kastet. Under kastuttalelsen er andre uttalelser som vil bli utført hvis ingen feil oppsto.

Fangstblokken over har en uttalelse. Det kan ha mer. Kastuttalelsen i Try-blokken kaster et unntaksobjekt, som blir fanget i parentesene til fangstblokksignaturen, for videre behandling i blokken. Denne aktiviteten ligner på en metodeanrop, med et argument som skal mottas av parentesene i metodeimplementeringen for videre behandling i blokken av metoden.

Husk at unntaksobjektet kan gjenkjenne forskjellige typer ordinære feil og takle dem. Unntaksobjektet har metoden, getMessage (). Denne metoden returnerer en melding som brukeren kan forstå som årsak til feilen. Denne metodeanropet brukes inne i fangstblokken.

Følgende program setter Try-Compound-uttalelsen i praksis, med ovennevnte divisjon-for-null problem:

public class theclass
public static void main (String [] args)
System.ute.println ("sett 1");
int teller = 6; int nevner = 0; int kvotient;
prøv
if (nevner == 0)
kvotient = teller / nevner;
Kast nytt unntak ();

ellers
kvotient = teller / nevner;
System.ute.println ("sett 2");
System.ute.println (kvotient);

fangst (unntak e)
System.ute.println ("unntaksmelding:" + e.getMessage ());

System.ute.println ("fortsetter");

Try-blokken har en if-compound-uttalelse. IF-delen ville utføre problemserklæringen når nevneren er null. Den andre delen ville utføre problemserklæringen når ingen feil skulle oppstå når nevneren ikke er null. Dette betyr at programmereren må veilede til ansettelse av unntakshåndteringsordningen. Og i dette tilfellet er problemstatningen blitt skrevet to ganger: en gang i IF-delen og en gang i annet-delen. Problemerklæringen er ikke gitt av INT fordi kvotienten er blitt erklært før Try Compound -uttalelsen.

I prøveblokken er kastuttalelsen rett under problemserklæringen i IF-delen av IF-Compound-uttalelsen. Det er ikke i annet del av IF-Compound-uttalelsen. Det trenger ikke å være der fordi den andre delen er for situasjonen når nevneren (operand) ikke er null (har ikke noe problem).

Les gjennom programmet ovenfor. Telleren er 6. Hvis nevneren var 2, ville utgangen vært:

sett 1
sett 2
3
Fortsetter

Dette betyr at den andre delen av IF-Compound-uttalelsen ble utført, ikke IF-delen av IF-Compound-uttalelsen. Faktisk ble IF-delen (koden) i IF-sammensatte uttalelse ikke utført fordi nevneren ikke var null. Resten av koden i prøveblokken ble utført. Resten av koden i prøveblokken er ment å bli utført.

Når nevneren er 0, vil programmet produsere utgangen:

sett 1
Unntaksmelding: / med null
Fortsetter

Bare koden i IF-delen av prøveblokken har blitt utført i denne situasjonen. Dette betyr at kasterklæringen ble utført. Den andre delen og koden under IF-Compound-uttalelsen er ikke utført. De blir normalt ikke henrettet i denne situasjonen.

Fangstblokken blir ikke utført når det ikke er noe problem. Nå ble fangstblokken henrettet. Det vil si at den eneste uttalelseskoden i fangstblokken ble utført. Det nye unntaksobjektet blir kastet, ble mottatt som e. GetMessage () -metoden til objektet, e som kjenner de vanlige feilene (inkludert feilen for divisjon-for-null) returnerte meldingen, “/ by null”.

Med denne feilen returnert, ville brukeren vite at det oppsto en feil i divisjon-for-null, og den ble håndtert. Håndtering, her, betyr at avdelingen for null ikke forårsaket noen skade på programmet, og selv om resten av koden under feilpunktet i Try-Compound-setningen ikke ville bli utført, vil koden under prøve- sammensatt uttalelse ville bli utført. Hvis håndteringsskjemaet ikke var til stede, ville programmet ha avsluttet, og noen kode nedenfor som ikke ville ha vært i prøve-sammensatte uttalelse, ville ikke blitt utført.

Kaste unntak, med en metode

I Java kan kastekspsjonserklæringen kaste et unntak i prøveblokken, som illustrert ovenfor. En metode kan også kaste et unntak, men med en annen syntaks, fremdeles relatert til prøveblokken. Kjernen i prøveblokkkoden er nå i metodekroppen og ikke i prøveblokken. Følgende program gjentar ovennevnte, men med en metode som kaster unntaket. Klassen med metodeimplementeringen er:

klasse aclass
int mthd (int num, int deno) kaster unntak
int quoti = num / deno;
Returner quoti;

Hovedkoden i metoden her er problemstillingen. Problemerklæringen er ikke lenger i prøveblokken (nedenfor). Problemerklæringen er skrevet en gang, her og for hele programmet (ikke skrevet to ganger). Kastuttrykket er nå annerledes. Det er,

kaster unntak

forlenge metodesignaturen til høyre. “Kast” her er “kast”, med en s. Unntak, her, har ikke parentesene.

Det er nå ikke behov for IF-Compound-uttalelsen i hele programmet. Metodens kropp og "kaster unntak" tjener formålet med semantikken i IF-Else Compound-uttalelsen. Hovedklassen blir:

public class theclass
public static void main (String [] args)
System.ute.println ("sett 1");
int teller = 6; int nevner = 0; int kvotient;
prøv
AclasseObj = new Aclass ();
kvotient = eobj.MTHD (teller, nevner);
System.ute.println ("sett 2");
System.ute.println (kvotient);

fangst (unntak e)
System.ute.println ("unntaksmelding:" + e.getMessage ());

System.ute.println ("fortsetter");

Den har fremdeles prøve-catch-sammensatt uttalelse. Imidlertid er problemuttalelsen ikke her og skrives ikke to ganger. If-elvesammenheng er heller ikke her. Det er ikke lenger nødvendig noe sted i programmet. Utgangen med feilmeldingen er den samme som før, i.e.

sett 1
Unntaksmelding: / med null
Fortsetter

Oppførselen til det komplette programmet er som før.

Den endelig leddet

Try -uttalelsen har tre klausuler: Try. Det kan være mer enn en fangstklausul - se senere. Den endelig blokken kommer på slutten av prøve-sammensatte uttalelse, og det er for programmereren å videreføre en melding til brukeren om at den mulige feilen ble håndtert. Koding av endelig leddet er valgfritt. Følgende kode illustrerer en bruk av endelig leddet for programmet ovenfor:

System.ute.println ("sett 1");
int teller = 6; int nevner = 0; int kvotient;
prøv
AclasseObj = new Aclass ();
kvotient = eobj.MTHD (teller, nevner);
System.ute.println ("sett 2");
System.ute.println (kvotient);

fangst (unntak e)
System.ute.println ("unntaksmelding:" + e.getMessage ());

endelig
System.ute.Println ("Enhver feil ble håndtert.");

Hvis nevneren er 2, vil utgangen være:

sett 1
sett 2
3
Enhver feil ble håndtert.
Fortsetter

Hvis nevneren er 0, vil utgangen være:

sett 1
Unntaksmelding: / med null
Enhver feil ble håndtert.
Fortsetter

Den endelig blokken utføres, enten det oppsto en feil eller ikke.

Konklusjon

Et unntak kastes, med den enkle uttalelsen i forsøksblokken, muligens kodet med en if-compound-uttalelse og problemstatningen. Et unntak kan fremdeles kastes med en metode i forhold til prøve-sammensatte uttalelse. Denne artikkelen har vært det grunnleggende om å kaste et unntak i Java.