Uitsonderings van Java en hoe om dit te hanteer

As Java-ontwikkelaar moet u 'n goeie kennis hê van Java-uitsonderings en hantering van uitsonderings.

Hierdie handleiding bied die basiese kennis wat elke programmeerder moet hê wanneer hy met Java-programme werk. Om te begin, moet ons eers begin verstaan ​​wat presies Java-uitsonderings is.



Wat is Java-uitsonderings

'N Java-program kan probleme ondervind wat daartoe lei dat die program skielik beëindig word tydens die uitvoering daarvan. Hierdie probleme word uitsonderings genoem.


'N Goeie programmeerder moet in staat wees om die foute wat tydens die uitvoering kan voorkom, te herken en alternatiewe roetes te gee wat die program kan volg in geval van sulke uitsonderings. Hierdie gebruik word uitsonderingshantering genoem.

Nou kan jy jou afvra waarom ons hoegenaamd uitsonderingshantering nodig het. Waarom skryf u nie programme wat nie uitsonderings kan oplewer nie?




Waarom het ons die hantering van uitsonderings nodig?

Soos dit blyk, is die skryf van programme wat nie uitsonderings sal oplewer nie so maklik soos dit klink nie. Hierdie onvermydelike foute val meestal buite die programmeerder se beheer.

Programme wat gebruikersinvoer aanvaar, kan uitsonderings raak as gevolg van 'n ongeldige invoer wat die gebruiker lewer. So is die lees van eksterne lêers ook die oorweging van die kans dat dit sonder die medewete van die programmeerder deur 'n eksterne bron geskuif, hernoem of verwyder is.

In sulke gevalle moet die program die uitsondering grasieus kan hanteer sonder om die uitvoering te beëindig.



Hiërargie van Java-uitsonderings

Al die uitsonderings in Java moet 'n kind van die Exception wees klas, wat self 'n kind van die Throwable is klas.


Twee hoofsubklasse van die Exception klas is RuntimeException en IOException.



Uitsondering vs Fout

Nog 'n kinderklas van die Throwable klas is die Error klas. Foute verskil egter van uitsonderings.

Foute dui op probleme waarmee die JVM tydens die uitvoering kan beland. Hierdie probleme is gewoonlik kritiek en onherstelbaar. Geheue-lekkasies en probleme met biblioteekversoenbaarheid is algemene redes vir foute in programme.

StackOverflowError en OutOfMemoryError is twee voorbeelde van Java-foute.




Gekontroleerde en ongemerkte uitsonderings

Ons kan Java-uitsonderings in twee hoofkategorieë verdeel: nagegaan en ongemerk uitsonderings.

Gekontroleerde uitsonderings is die uitsonderings wat in die program hanteer moet word voordat dit saamgestel word. As hierdie uitsonderings nie hanteer word nie, sal die program nie deur die Java-samesteller saamgestel word nie. Daarom word dit ook kompileringstyduitsonderings genoem. IOExceptions is goeie voorbeelde van uitgesoekte uitsonderings.

Ongekontroleerde uitsonderings is die uitsonderings wat die samesteller ignoreer tydens die samestelling van die program. Of ons hierdie uitsonderings in die program hanteer het of nie, maak nie saak wanneer die program saamgestel word nie. Aangesien uitsonderings nie op hierdie uitsonderings gehanteer word nie, kan ons program RuntimeExceptions beloop wat lei tot die beëindiging van die program.

Al die klasse wat die RuntimeException uitbrei klas is ongemerkte uitsonderings. Twee voorbeelde van sulke klasse is NullPointerException en ArrayIndexOutOfBoundsException.




Gewoonlik gebruikte metodes in die uitsonderingsklas

Ons gaan 'n paar algemene metodes in die Java Exception deur klas:

  1. getMessage: stuur 'n boodskap terug met besonderhede oor die uitsondering wat plaasgevind het.
  2. printStackTrace: gee die stapelspoor van die uitsondering terug.
  3. toString: gee die klasnaam en die boodskap wat met getMessage teruggestuur word metode.


Hoe om uitsonderings te hanteer

Kom ons kyk hoe ons uitsonderings in Java kan hanteer:

probeer-vang

Ons kan uitsonderings opneem en dit behoorlik hanteer met behulp van a probeer-vang blokkeer in Java.

In hierdie sintaksis word die deel van die kode wat geneig is om 'n uitsondering te gooi in 'n driehoek geplaas en die vangblok / -blokke vang die uitgesonderde uitsondering / uitsonderings en hanteer dit volgens die logika wat ons bied.


Die basiese sintaksis van 'n vang-blok is soos volg:

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

Met hierdie benadering stop die program nie die uitvoering van 'n uitsondering deur die program nie, maar dit word grasieus hanteer.

Ons sal sien hoe om die IOExceptions te hanteer gegooi deur die FileReader klas in 'n Java-program.

Voorbeeld:

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();
}
} }

Hier het ons 'n enkele vangblok gebruik om die FileNotFoundException te hanteer gegooi wanneer die FileReader geïnstalleer word klas en IOException gegooi deur die read() metode van die FileReader klas.

Albei hierdie uitsonderings is kinders van die Exception klas.

Ons kan ook veelvuldige vangstate gebruik om verskillende soorte foute op te vang wat deur die kode in die enkele drie-verklaring gegooi word. Vir die vorige voorbeeld kan ons een vangblok gebruik om die FileNotFoundException te vang en nog 'n vangsblok vir die IOException soos die volgende kode bevat:

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();
}
} }

As die uitgesonderde uitsondering ooreenstem met die uitsondering wat deur die eerste vangsverklaring hanteer word, word dit hanteer deur die logika in die eerste vangsverklaring.

As die uitsonderings nie ooreenstem nie, word dit deurgegee na die tweede vangsverklaring. As daar meer as twee vangsstate is, gaan hierdie proses voort totdat die uitsondering 'n vangsverklaring bereik wat die soort vang.

Sedert FileNotFoundException is 'n subtipe van IOException, wat die 2de vangsstelling gebruik om 'n FileNotFoundException te vang sal nie werk nie. Dit sal deur die eerste vangsverklaring hanteer word en nooit die tweede verklaring bereik nie.

Nota:Dit is verpligtend om ten minste een vangsverklaring saam met 'n drie-verklaring te gebruik.

uiteindelik

Wanneer ons 'n probeer-vang blok om uitsonderings in ons program op te vang, is daar gevalle dat ons 'n mate van logika wil implementeer, ondanks die feit of 'n uitsondering gevang is of nie. In sulke gevalle kan ons a probeer-vang-uiteindelik blok in plaas van net 'n probeer-vang blokkeer.

Dan, die kode in die finally verklaring word geïmplementeer of 'n uitsondering al dan nie voorkom. Die finally verklaring moet altyd aan die einde van die probeer-vang-eind-blok kom.

Byvoorbeeld, wanneer ons die FileReader gebruik klas om 'n lêer te lees, is dit noodsaaklik om die geopende lêer aan die einde van die verwerking te sluit, ongeag of daar 'n uitsondering is. Om dit te verseker, kan ons die kode plaas om die lêer in 'n finally te sluit verklaring.

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();
}
} }

As u egter die bogenoemde kode probeer saamstel, sal die kode nie saamgestel word nie as gevolg van 'n onbehandelde IOException Dit is omdat die close() metode van die FileReader klas kan ook gooi IOExceptions. Dus, ons moet hierdie deel in 'n ander driehoek so plaas:

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();

}
}
} }

gooi

Hanteer foute met die throws sleutelwoord in Java is eenvoudig. In hierdie benadering hanteer u die uitsondering nie regtig op die plek waar dit voorkom nie. In plaas daarvan gooi ons die uitsondering uit die huidige metode op die metode wat die huidige metode genoem word. Die oorhandiging van die fout word dan die verantwoordelikheid van die buitenste metode.

Om 'n uitsondering uit 'n metode te gooi, moet u eenvoudig verklaar dat hierdie metode die oorweegse uitsondering mag gooi. Kom ons kyk hoe ons IOExceptions kan hanteer gegooi deur die FileReader klas gebruik deur hierdie benadering te gebruik.

Voorbeeld:

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();
} }

gooi

Anders as ander benaderings in hierdie lys, is die throw sleutelwoord word nie gebruik om foute te hanteer nie. Maar aangesien die meeste mense die throw verwar sleutelwoord met throws sleutelwoord, ons het gedink dat dit die beste sal wees om dit hier te bespreek.

Die throw sleutelwoord word gebruik om 'n uitsondering uitdruklik op te roep. Ons kan 'n pas geïnitieerde uitsondering of 'n uitsondering wat in die metode vasgevang is, gooi.

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

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


Gebruikersgedefinieerde uitsonderings

Benewens die gebruik van ingeboude Java-uitsonderings, kan u ook u eie uitsonderings definieer. U kan dit definieer as gemerkte of ongemerkte uitsonderings. Om 'n nuwe gekontroleerde uitsondering te skep, moet u nuwe uitsondering die Exception uitbrei klas.

Om 'n ongemerk uitsondering, brei die RuntimeException uit klas.

In die volgende kode-voorbeeld het ons 'n deur gebruiker gedefinieerde uitsondering geskep:

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;
} }

Nou kan ons die bostaande uitsondering in ons programlogika so gebruik:

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');
}
} }

As ons die lengte van 'n tou met behulp van die InputChecker nagaan klas, sal dit 'n InvalidLengthException gooi as die snaarlengte onder die minimum lengte of bo die maksimum lengte is.

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();
}
} }

As ons die bostaande kodeblad uitvoer, sal dit 'n InvalidLengthException gooi en ons sal die volgende uitsette kry:

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


Afsluiting

In hierdie handleiding het ons u 'n vinnige en bondige inleiding gegee tot Java Exceptions. Ons hoop dat u nou 'n goeie begrip het van wat uitsonderings is en hoe u dit in u Java-program moet hanteer.