Java-unntak og hvordan du håndterer dem

Som Java-utvikler bør du ha god kunnskap om Java-unntak og håndtering av unntak.

Denne opplæringen gir grunnleggende kunnskap som alle programmerere må ha når de jobber med Java-programmer. For å begynne med, la oss begynne med å forstå hva Java-unntak er.



Hva er Java-unntak

Et Java-program kan støte på problemer som resulterer i at programmet blir brått avsluttet under utførelsen. Disse problemene kalles unntak.


En god programmerer skal kunne gjenkjenne feilene som kan oppstå under utførelsen, og gi alternative ruter for programmet å ta i tilfelle et slikt unntak. Denne praksisen kalles unntaksbehandling.

Nå lurer du kanskje på hvorfor trenger vi i det hele tatt håndtering av unntak. Hvorfor ikke skrive programmer som ikke gir unntak?




Hvorfor trenger vi håndtering av unntak

Det viser seg at det ikke er så enkelt å skrive programmer som ikke gir unntak som det høres ut. Mesteparten av tiden er disse uunngåelige feilene utenfor programmererens kontroll.

Programmer som godtar brukerinngang, er utsatt for unntak på grunn av ugyldig inndata brukeren gir. Så er å lese eksterne filer med tanke på sjansen for at de har blitt flyttet, omdøpt eller slettet av en ekstern kilde uten kjennskap fra programmereren.

I slike tilfeller må programmet kunne håndtere unntaket elegant, uten å avslutte utførelsen.



Hierarki av Java-unntak

Alle unntakene i Java bør være et barn av Exception klasse, som i seg selv er et barn av Throwable klasse.


To hovedunderklasser av Exception klasse er RuntimeException og IOException.



Unntak vs Feil

Nok en barneklasse av Throwable klasse er Error klasse. Feil er imidlertid forskjellig fra unntak.

Feil indikerer problemer som JVM kan støte på under utførelsen. Disse problemene er vanligvis kritiske og uopprettelige. Minnelekkasjer og bibliotekskompatibilitetsproblemer er vanlige årsaker til feil i programmer.

StackOverflowError og OutOfMemoryError er to eksempler på Java-feil.




Merkede og ukontrollerte unntak

Vi kan dele Java-unntak i to hovedkategorier: sjekket og ukontrollert unntak.

Merkede unntak er unntakene som må håndteres i programmet før kompilering. Hvis disse unntakene ikke håndteres, blir ikke programmet kompilert av Java-kompilatoren. Derfor kalles disse også unntak for kompileringstid. IOExceptions er gode eksempler på avmerkede unntak.

Uavmerkede unntak er unntakene som kompilatoren ignorerer når du kompilerer programmet. Om vi ​​har håndtert disse unntakene i programmet eller ikke, spiller ingen rolle når programmet blir samlet. Siden unntakshåndtering ikke er pålagt disse unntakene, kan programmet vårt løpe på RuntimeExceptions som resulterer i programavslutning.

Alle klassene som utvider RuntimeException klasse er ukontrollerte unntak. To eksempler på slike klasser er NullPointerException og ArrayIndexOutOfBoundsException.




Vanlige metoder i unntaksklassen

Vi går gjennom noen vanlige metoder i Java Exception klasse:

  1. getMessage: returnerer en melding som inneholder detaljer om unntaket som oppstod.
  2. printStackTrace: returnerer stakkspor av unntaket som oppstod.
  3. toString: returnerer kursnavnet og meldingen som returneres med getMessage metode.


Hvordan håndtere unntak

La oss se hvordan vi kan håndtere unntak i Java:

prøvefangst

Vi kan fange unntak og håndtere dem riktig ved hjelp av en prøvefangst blokker i Java.

I denne syntaksen er den delen av koden som er utsatt for å kaste et unntak plassert i en prøveblokk, og fangstblokken / blokkene fanger det kastede unntaket / unntakene og håndterer dem i henhold til en logikk vi gir.


Den grunnleggende syntaksen til en prøvefangstblokk er som følger:

try {
//exception-prone code } catch(Exception e) {
//error handling logic }

Med denne tilnærmingen stopper ikke programmet utførelsen når et unntak blir kastet av programmet, i stedet blir det elegant behandlet.

Vi får se hvordan vi håndterer IOExceptions kastet av FileReader klasse i et Java-program.

Eksempel:

import java.io.FileReader; public class TryCatchBlockExample {
public static void main(String[] args) {

try {

FileReader file = new FileReader('source.txt');

file.read();
}
catch(Exception e) {

e.printStackTrace();
}
} }

Her har vi brukt en enkelt fangstblokk for å håndtere FileNotFoundException kastet når du starter FileReader klasse og IOException kastet av read() metoden til FileReader klasse.

Begge disse unntakene er barn av Exception klasse.

Vi kan også bruke flere fangstuttrykk for å fange forskjellige typer feil kastet av koden i utsagnet om enkeltforsøk. For det forrige eksemplet kan vi bruke en fangstblokk for å fange FileNotFoundException og en annen fangstblokk for IOException som følgende kodebit viser:

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchBlockExample {
public static void main(String[] args) {

try {

FileReader file = new FileReader('source.txt');

file.read();

file.close();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
} }

Hvis det kastede unntaket samsvarer med unntaket som håndteres av den første fangstuttalelsen, blir det håndtert av logikken i den første fangstuttalelsen.

Hvis unntakene ikke stemmer overens, videreføres det til den andre fangstoppgaven. Hvis det er mer enn to fangstutsagn, fortsetter denne prosessen til unntaket når en fangstoppgave som fanger sin type.

Siden FileNotFoundException er en undertype på IOException, som bruker den andre fangstoppgaven for å fange en FileNotFoundException vil ikke fungere. Den vil bli håndtert av den første fangstoppgaven og kommer aldri til den andre uttalelsen.

Merk:Det er obligatorisk å bruke minst en fangstuttalelse med en prøveerklæring.

endelig

Når vi bruker en prøvefangst blokkere for å fange unntak i programmet vårt, er det tilfeller vi ønsker å implementere noen logikk til tross for om et unntak ble fanget opp eller ikke. I slike tilfeller kan vi bruke en prøv-fang-endelig blokker i stedet for bare en prøvefangst blokkere.

Deretter koden i finally uttalelse er implementert uansett om det oppstår et unntak. finally uttalelse skal alltid komme på slutten av blokken for prøve-fang-endelig.

For eksempel når vi bruker FileReader klasse for å lese en fil, er det viktig å lukke den åpnede filen på slutten av behandlingen enten det oppstår et unntak eller ikke. For å sikre dette kan vi plassere koden for å lukke filen i en finally uttalelse.

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;
try {

file = new FileReader('source.txt');

file.read();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
finally {

file.close();
}
} }

Hvis du prøver å kompilere koden ovenfor, blir koden imidlertid ikke kompilert på grunn av et uhåndtert IOException Dette er fordi close() metoden til FileReader klasse kan også kaste IOExceptions. Så vi må plassere denne delen i en annen prøveblokk slik:

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;

try {

file = new FileReader('source.txt');

file.read();
}
catch(FileNotFoundException e) {

e.printStackTrace();
}
catch(IOException e) {

e.printStackTrace();
}
finally {

try {


file.close();

}

catch(IOException e) {


e.printStackTrace();

}
}
} }

kaster

Håndteringsfeil ved bruk av throws nøkkelord i Java er enkelt. I denne tilnærmingen håndterer du faktisk ikke unntaket på stedet der det forekommer. I stedet kaster vi unntaket fra den gjeldende metoden til metoden som kalte den gjeldende metoden. Deretter blir utlevering av feil et ansvar for den ytre metoden.

For å kaste et unntak ut av en metode, må du bare erklære at denne metoden kan kaste det vurderte unntaket. La oss se hvordan vi kan takle IOExceptions kastet av FileReader klasse ved hjelp av denne tilnærmingen.

Eksempel:

import java.io.FileReader; import java.io.IOException; public class ThrowsExample {
public void readFile throws IOException {
FileReader file = new FileReader('source.txt');
file.read();
file.close();
} }

kaste

I motsetning til andre tilnærminger i denne listen, er throw nøkkelord brukes ikke til å håndtere feil. Men siden de fleste forveksler throw nøkkelord med throws nøkkelord, vi trodde det ville være best å diskutere det her.

throw nøkkelord brukes til å eksplisitt påkalle et unntak. Vi kan kaste et nylig instansert unntak eller et unntak som ble fanget inne i metoden.

public class ThrowExample {
public void invalidate(int amount) throws Exception {
if (amount < 500) {

throw new Exception('Amount not sufficient');
}
} }


Brukerdefinerte unntak

I tillegg til å bruke innebygde Java-unntak, kan du definere dine egne unntak. Du kan definere dem som enten avmerkede eller ukontrollerte unntak. For å opprette et nytt merket unntak, bør det nye unntaket utvide Exception klasse.

Å lage en ukontrollert unntak, utvid RuntimeException klasse.

I følgende kodeeksempel har vi opprettet et brukerdefinert avkrysset unntak:

public class InvalidLengthException extends Exception {
private int length;
private String message;
public InvalidLengthException(int length, String message) {
this.length=length;
this.message=message;
}
public int getAmount() {
return this.length;
}
public String getMessage() {
return this.message;
} }

Nå kan vi bruke unntaket ovenfor i programlogikken vår slik:

public class InputChecker {
private int minLength;
private int maxLength;
public InputChecker(int minLength, int maxLength) {
this.minLength=minLength;
this.maxLength=maxLength;
}
public void checkStringLength(String strInput) throws InvalidLengthException {
int strLength = strInput.length();
if (strLength maxLength){

throw new InvalidLengthException(strLength, 'Input should have maximum '+maxLength+' character');
}
} }

Hvis vi sjekker lengden på en streng ved hjelp av InputChecker klasse, vil det kaste et InvalidLengthException hvis strenglengden er under minimumslengden eller over maksimumslengden.

public class Main {
public static void main(String[] args) {
InputChecker ic = new InputChecker(2, 7);
try {

ic.checkStringLength('longer than the maximum length');
}
catch(InvalidLengthException e) {

e.printStackTrace();
}
} }

Når vi kjører kodebiten ovenfor, vil den kaste et InvalidLengthException og vi vil få følgende utdata:

InvalidLengthException: Input should have maximum 7 character
at InputChecker.checkStringLength(InputChecker.java:17)
at Main.main(Main.java:6)


Konklusjon

I denne opplæringen ga vi deg en rask og kortfattet introduksjon til Java Unntak. Vi håper at du nå har god forståelse av hva som er unntak og hvordan du håndterer dem i Java-programmet ditt.