java exceptions exception handling with examples
Denne videoundervisning om Java-undtagelser Forklarer alt om undtagelseshåndtering i Java. Du lærer om undtagelseshierarki, typer, klassemetoder og mere:
Når vi udfører Java-programmer, afbrydes programmets normale adfærd eller normale strøm på grund af nogle uventede begivenheder.
For eksempel, vi åbner en fil til læsning af dataene. Når opkaldet Åbn fil udføres, finder vi den fil, vi prøver at åbne, mangler. Dette resulterer i afbrydelse af den normale strøm af programmet.
Denne begivenhed, der påvirker eller afbryder den normale strøm af programmet, kaldes “ Undtagelse ”.
=> Besøg her for at udforske Java-træningsserien for alle.
Her er en videovejledning om håndtering af Java-undtagelser:
Hvad du vil lære:
Undtagelse Håndtering i Java
Når der forekommer en undtagelse i programmet, afsluttes programudførelsen. Da dette er en brat afslutning, genererer systemet en besked og viser den. Beskeden genereret af systemet kan være kryptisk som nogle koder eller ulæselige.
Således skulle den normale bruger forstå, hvorfor programmet brat stoppede dets udførelse, han / hun skulle vide årsagen. De systemgenererede meddelelser som følge af undtagelse er muligvis ikke nyttige. I Java kan vi håndtere undtagelsen og give meningsfulde meddelelser til brugeren om problemet.
Denne håndtering af undtagelse, almindeligvis kendt som “Undtagelse håndtering” er en af de fremtrædende funktioner ved Java-programmering.
Årsager til, at undtagelsen kan forekomme
Vi kan have forskellige grunde til, at undtagelser kan forekomme. Hvis det er en undtagelse relateret til input, kan årsagen være, at inputdataene er forkerte eller ulæselige.
Hvis vi får en undtagelse for fil I / O, er det meget muligt, at de filer, vi har at gøre med, ikke findes. På et andet tidspunkt kan der være fejl som netværksproblemer, printeren er ikke tilgængelig eller fungerer osv.
I et program, bortset fra undtagelser, får vi også fejl. For at håndtere undtagelserne effektivt skal vi således være opmærksomme på forskellene mellem fejl og en undtagelse.
En fejl angiver et mere alvorligt problem med applikationen, og applikationen bør ikke forsøge at fange den. Tværtimod er undtagelsen en betingelse for, at enhver rimelig anvendelse vil forsøge at fange.
Således er en fejl i applikationen mere alvorlig, og applikationerne vil gå ned, når de støder på en fejl. Undtagelser på den anden side forekommer i kode og kan håndteres af programmøren ved at give korrigerende handlinger.
Hvad er undtagelseshåndtering?
Undtagelseshåndtering i Java er en mekanisme, hvorved den normale strøm af applikationen opretholdes. For at gøre dette anvender vi en kraftig mekanisme til at håndtere runtime-fejl eller undtagelser i et program.
En sekvens af kode, der bruges til at håndtere undtagelsen, kaldes 'Undtagelsesbehandler'. En undtagelsesbehandler forhører konteksten på det tidspunkt, hvor undtagelsen opstod. Dette betyder, at det læser de variable værdier, der var inden for omfanget, mens undtagelsen opstod, og derefter gendanner Java-programmet for at fortsætte med det normale flow.
Fordele ved undtagelseshåndtering
Den største fordel ved undtagelseshåndtering er, at den opretholder den normale strøm af applikationen trods forekomsten af en undtagelse. Når en undtagelse opstår, afsluttes programmet normalt brat.
At have en undtagelsesbehandler i et program får ikke programmet til at ophøre brat. I stedet sørger en undtagelsesbehandler for, at alle udsagn i programmet udføres normalt, og programgennemstrømningen ikke går brat.
Undtagelseshierarki i Java
Nedenstående diagram viser undtagelseshierarkiet i Java. Klassen java.lang.Throwable (efterkommer af objektklassen) er rodklassen for Java Exception. Klasserne Undtagelse og Fejl stammer fra denne klasse.
Undtagelsesklasse er basisklassen for alle de andre undtagelser.
Nedenfor er et hierarki af Exception-klassen i Java, der viser alle de vigtigste undtagelser, som en Java-programmør skal være opmærksom på.
Undtagelsesklasse i Java
Som det ses i hierarkidiagrammet, har klasse Throwable to direkte underklasser, dvs. undtagelse og fejl. Undtagelser, der opstår fra en ekstern kilde, er beskrevet i klassen Undtagelse.
Exception-klassen erklærer konstruktørerne som de samme som Throwable-klassen, og påkaldelse af hver konstruktør påberåber sig også sin Throwable-modstykke. Undtagelsesklasse erklærer ikke sine metoder, den arver Throwable-klassemetoder.
De konstruktører og metoder, som Exception-klassen bruger, er vist nedenfor.
Konstruktører
Bygger Beskrivelse offentlig undtagelse () En standardkonstruktør, der konstruerer en ny undtagelse med meddelelsen som null. offentlig undtagelse (streng besked) Konstruktør til at konstruere en ny undtagelse med den givne besked. I dette tilfælde initialiseres årsagen ikke, og et efterfølgende opkald til Throwable.initCause (java.lang.Trowable) kan bruges til at initialisere årsagen. offentlig undtagelse (streng besked, årsag, der kan kastes) Konstruerer en ny undtagelse ved hjælp af en given meddelelse og årsag. offentlig undtagelse (kastbar årsag) Konstruerer en ny undtagelse med den givne årsag og en besked givet af (årsag == null? Null: årsag.tilString ()) (som typisk indeholder årsag til klasse og detaljeret årsag). beskyttet undtagelse (strengbesked, smidbar årsag, boolsk mulig undertrykkelse, boolsk skrivbar stakspor) Konstruerer en ny undtagelse med den givne meddelelse, årsag, undertrykkelse (aktiveret eller deaktiveret) og den skrivbare staksporing (aktiveret eller deaktiveret).
Metoder
Metode Prototype | Beskrivelse |
---|---|
offentlig streng getMessage () | Få en detaljeret besked om den undtagelse, der opstod. |
offentlig kastbar getCause () | Få årsagen til undtagelsen repræsenteret af et kastbart objekt |
offentlig String toString () | Sammenkæder klassens navn med resultatet af getMessage () og returnerer den resulterende streng. |
offentlig ugyldig printStackTrace () | Udskriver resultatet af toString () og indholdet af staksporingen til fejloutputstrømmen System.err. |
offentlig StackTraceElement [] getStackTrace () | Få hvert element i stakksporingen i form af en matrix. |
public Throwable fillInStackTrace () | Udfyld stakksporingen med det aktuelle stackspor. |
Undtagelseseksempel
Dernæst præsenterer vi et Java-program for at demonstrere et grundlæggende eksempel på undtagelse. Her giver vi en strengvariabel initialiseret til en nulværdi. Når vi prøver at udskrive denne variabel, kastes en undtagelse, da strengværdien ikke kan være nul.
class Main { public static void main(String args[]){ //declare a String variable and initialize it to null String myStr = null; //print the string System.out.println(myStr.length()); } }
Produktion
Typer af undtagelser i Java
Java understøtter tre typer undtagelser:
- Kontrolleret undtagelse
- Ikke markeret undtagelse
- Fejl
I dette afsnit vil vi diskutere alle de ovennævnte tre typer.
# 1) Kontrolleret undtagelse
Nogle undtagelser kontrolleres på kompileringstidspunktet, når koden kompileres. Disse er 'Kontrollerede undtagelser'. Java-programmet kaster en kompileringsfejl, når det finder ud af, at koden inde i et program er udsat for fejl.
Vi kan tage os af kompileringsfejlene, der smides af kontrolleret undtagelse, ved at håndtere undtagelserne ved enten at omslutte koden i en prøvefangst-blok eller ved at bruge kaster-nøgleordet.
I undtagelseshierarkiet er den klasse, der direkte arver Throwable-klassen som IOException, ClassNotFoundException osv., Alle kontrolleret undtagelser undtagen klasserne RuntimeException og Error. Dette er ukontrollerede undtagelser.
Følgende Java-program demonstrerer de kontrollerede undtagelser, FileNotFoundException og IOException. I dette program forsøger vi at åbne en ikke-eksisterende fil og læse fra den.
software til at downloade videoer fra dit tube
Da filen ikke findes, kaster den åbne filmetode FileNotFoundException. Dernæst, når vi prøver at læse indholdet af filen og lukke filen, kaster metodekaldene IOException.
import java.io.*; class Main { public static void main(String args[]) { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }
Produktion
I ovenstående output, da undtagelsesbehandleren er fraværende, får vi kompileringsfejl for kontrollerede undtagelser.
Lad os nu give en kasteklausul for dette program. Da FileNotFoundExceptions forælder er IOException, specificerer vi bare IOException efter kast-klausulen.
import java.io.*; class Main { public static void main(String args[]) throws IOException { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }
Produktion
Som det ses af output, når vi håndterer undtagelsen, giver det mere meningsfuld output i stedet for kompileringsfejl.
# 2) Ikke-markeret undtagelse
Ikke-markerede undtagelser er de undtagelser, der kontrolleres på kørselstidspunktet. Derfor på trods af undtagelser vil en samling af programmer være vellykket. De fleste af de ukontrollerede undtagelser kastes på grund af de dårlige data, der bruges i programmet.
Klasser, der arver “RuntimeException”, er ukontrollerede undtagelser. Undtagelser som ArrayIndexOutofBounds Exception, ArithmeticException, NullPOinterException osv. Er eksempler på ukontrollerede undtagelser.
Det følgende program viser en ukontrolleret undtagelse for runtime, der skyldes at dividere et tal med nul.
class Main { public static void main(String args[]) { int num1=10; int num2=0; //divide both numbers and print the result int result=num1/num2; System.out.println(result); } }
Produktion
Vi ser, at programmet er kompileret med succes, og derefter kastes ArithmeticException ved kørselstid.
Eksempler på ukontrolleret undtagelse:
- ArrayIndexOutOfBoundsException
- NullPointerException
- IllegalArgumentException
- NumberFormatException
Bortset fra ovenstående to undtagelser er der få flere kontrollerede undtagelser, herunder:
- SQLException
- InvocationTargetExecption
# 3) Fejl
Fejl er normalt en irreversibel og uoprettelig situation i et program, og når der opstår en fejl, går programmerne ned. Nogle af eksemplerne på fejl i et program er OutOfMemoryError, AssertionError og VirtualMachineError osv.
Fejlklasse arver fra klassen Throwable. Fejl beskriver en situation, der ikke kan håndteres og resulterer i, at et program går ned.
Lad os diskutere OutOfMemory-fejlen i dette afsnit som et eksempel på fejl.
Vi ved, at alle objekterne i Java tildeles ved hjælp af den nye operator og er gemt på bunken. Når bunken går tør for hukommelse, kan Java Virtual Machine (JVM) ikke allokere objektet. Samtidig kan affaldssamleren ikke frigøre nogen hukommelse. Denne situation giver anledning til OutOfMemory-fejlen.
OutOfMemoryError i Java ser ud som vist nedenfor:
'exception in thread 'main' java.lang.outofmemoryerror: java heap space'
Tilstedeværelsen af OutOfMemoryError i et program betyder, at der behandles for meget data, eller at objekterne holdes for længe. Nogle gange kan det også være et tredjepartsbibliotek, der bruger hukommelse.
Årsager til OutOfMemoryError
# 1) Java Heap Space
Hvis en applikation har for mange færdiggørere, genvindes klasseobjekterne, der har metoden Færdiggørelse, ikke straks af affaldssamleren, men står i kø til færdiggørelse på et senere tidspunkt. Nogle gange kan færdiggørelsen ikke holde trit med tiden, og bunkehukommelsen udfyldes, hvilket resulterer i OutOfMemoryError.
En anden grund til OutOfMemoryError er, at den angivne bunkestørrelse kan være utilstrækkelig til applikationen.
Den følgende kode viser OutOfMemoryError, der kan opstå på grund af en enorm datastørrelse, der er deklareret for en matrix.
import java.util.*; public class Main { static List list = new ArrayList(); public static void main(String args[]) throws Exception { Integer[] array = new Integer[100000 * 100000]; } }
Produktion
# 2) Permgen Space
Permanent generationsområde i hukommelsen kan også være opbrugt og kunne generere OutOfMemory-fejl.
Størrelsen på PermGen-regionen indstilles under JVM-lanceringen. Hvis brugeren ikke indstiller størrelsen, bruges standardstørrelsen, der er platformsspecifik.
Selvom de ovennævnte to normalt er hovedårsagerne til OutOfMemoryError-forekomst, kan der være andre årsager som Array-størrelse, der overstiger VM-grænsen osv.
Liste over undtagelser i Java
Nedenfor er en liste over de vigtigste undtagelser, der forekommer i Java. Vi har leveret programmeringseksempler på nogle af disse undtagelser. Bemærk, at disse er indbyggede undtagelser, der understøttes af Java.
# 1) Aritmetisk undtagelse: Aritmetiske abnormiteter som divideret med nul resulterer i ArithmeticException.
Nedenstående program viser forekomsten af ArithmeticException.
class Main { public static void main(String args[]) { try { //define two numbers int num1 = 100, num2 = 0; int result = num1 / num2; // divide by zero //print the result System.out.println('Result = ' + result); } catch (ArithmeticException e) { System.out.println('ArithmeticException:Division by Zero'); } } }
Produktion
# 2) ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException kastes, når et array-element åbnes ved hjælp af et ulovligt indeks. Det anvendte indeks er enten uden for arrayets størrelse eller er negativt.
# 3) ClassNotFoundException: Hvis klassedefinitionen ikke findes, hæves ClassNotFoundException.
# 4) FileNotFoundException: FileNotFoundException gives, når filen ikke findes eller ikke åbnes.
# 5) IO-undtagelse: IOException kastes, når input-output-operationen mislykkes eller afbrydes.
# 6) InterruptedException: Hver gang en tråd behandler eller sover eller venter, afbrydes den ved at kaste InterruptedException.
# 7) NoSuchFieldException: Hvis en klasse ikke indeholder et bestemt felt eller en bestemt variabel, kaster den NoSuchFieldException.
# 8) NoSuchMethodException: Når metoden der er adgang til ikke findes, hæves NoSuchMethodException.
# 9) NullPointerException: NullPointerException hæves, når et null-objekt henvises. Dette er den vigtigste og mest almindelige undtagelse i Java.
# 10) NumberFormatException: Denne undtagelse hæves, når en metode ikke kunne konvertere en streng til et numerisk format.
# 11) RuntimeException: Enhver undtagelse, der opstår ved kørsel, er en RuntimeException.
# 12) StringIndexOutOfBoundsException: StringIndexOutOfBoundsException kastes af String-klassen og indikerer, at indekset er uden for String-objektets størrelse eller er negativt.
# 13) EOFEekseption: EOFException er en del af java.io-pakken og smides, når filens slutning er nået, og filen læses.
# 14) IllegalArgumentException: IllegalArgumentException smides, når ulovlige eller ugyldige argumenter sendes til metoden. For eksempel, det forkerte dataformat, nulværdi, når ikke-nul er påkrævet eller argumenter uden for området.
Nedenstående Java-program demonstrerer IllegalArgumentException.
public class Main { int m; public static void setMarks(int marks) public static void main(String[] args) { setMarks(45); setMarks(101); } }
Produktion
I ovenstående program kastes IllegalArgumentException i det andet opkald til setMarks-funktionen, hvor vi indtaster de mærker, der er uden for rækkevidde (> 45).
# 15) InputMismatchException: InputMismatchException kastes, når inputlæsningen ikke matcher et specificeret mønster. For eksempel, Hvis programmet forventer heltal og læser en float, hæves InputMismatchException.
# 16) NoSuchElementException: NoSuchElementException kastes, når det næste tilgængelige element ikke findes.
For eksempel, i Opregning bruges metoden nextElement () til at få adgang til det næste element i optællingen. Hvis elementet ikke findes, kastes NoSuchElementException. For det meste kaster Java Collections denne undtagelse.
Programmet nedenfor viser dette.
import java.util.*; public class Main { public static void main(String[] args) { Set hash_Set = new HashSet(); //create an empty hashSet. //This throws NoSuchElementException since hashSet is empty hash_Set.iterator().next(); } }
Produktion
systemovervågningsværktøjer til Windows 10
# 17) ConcurrentModificationException: ConcurrentModificationException kastes normalt af samlingsklasser. Denne undtagelse kastes, når objekterne forsøger at ændre en ressource samtidigt.
For eksempel, en tråd kan ikke ændre en samling, når en anden tråd har adgang til den. Hvis vi tillader to tråde, vil disse to samtidig få adgang til samlingen, og der vil være uoverensstemmelser.
Følgende eksempel viser ConcurrentModificationException.
import java.awt.List; import java.util.*; public class Main { public static void main(String[] args) { ArrayList A_list = new ArrayList<>(); //add elements to the ArrayList A_list.add(10); A_list.add(20); A_list.add(30); Iterator it = A_list.iterator(); while (it.hasNext()) { Integer value = it.next(); System.out.println('ArrayList Value:' + value); if (value.equals(30)) A_list.remove(value); } } }
Produktion
Mens ArrayList udskrives i ovenstående program, prøver vi at slette et element på samme tid. Dette er den samtidige adgang, og dermed kastes en undtagelse.
Brugerdefinerede undtagelser i Java
Indtil videre har vi diskuteret alle undtagelser, der er indbygget eller leveret af Java-sprog. Bortset fra disse undtagelser kan vi også definere vores egne undtagelser. Disse kaldes brugerdefinerede undtagelser eller brugerdefinerede undtagelser.
Ved hjælp af brugerdefinerede undtagelser kan vi definere vores undtagelser efter vores behov.
Det følgende eksempel viser den brugerdefinerede undtagelse, som vi definerede for en heltalværdi.
//custom exception definition class InvalidValueException extends Exception{ InvalidValueException(String s){ super(s); } } class Main{ static void validate(int int_val)throws InvalidValueException{ if(int_val<10) //value is valid if> 10 else throw exception throw new InvalidValueException('Invalid value'); else System.out.println('This is valid integer'); } public static void main(String args[]){ try{ validate(9); }catch(Exception m){System.out.println('Exception occured: '+m);} System.out.println('Code after Exception'); } }
Produktion
Ofte stillede spørgsmål
Q # 1) Hvad mener du med undtagelse?
Svar: En begivenhed, der opstår under udførelsen af et program og forstyrrer programmets normale udførelsesflow, kaldes undtagelse. Undtagelsen er uønsket og uventet og kan forekomme på grund af eksterne faktorer eller programmeringsfejl.
Q # 2) Hvad er forskellen mellem fejl og undtagelse?
Svar: Undtagelser er begivenheder, der forstyrrer den normale strøm af programmet. Vi kan håndtere undtagelser i vores program og fortsætte med programmet normalt. En fejl er en uoprettelig begivenhed, der ikke kan håndteres og afslutter programmet.
Spørgsmål nr. 3) Hvad mener du med undtagelseshåndtering?
Svar: Processen med at specificere rækkefølgen af trin i et program til håndtering af undtagelsen kaldes Exception Handling. Ved at levere undtagelsesbehandlere i et program kan vi sikre den normale strøm af programmet.
Spørgsmål nr. 4) Hvad er fordelene ved undtagelseshåndtering i Java?
Svar: Ved hjælp af undtagelseshåndtering kan vi opretholde den normale strøm af udførelsen af en applikation. Vi kan også udbrede fejlene op i opkaldsstakken, når vi leverer undtagelsesbehandlere.
Q # 5) Hvad er brugen af undtagelseshåndtering?
Svar: Ikke at afslutte den normale strøm af eksekvering af en applikation er den største brug af at have undtagelsesbehandlere i et program. Uden undtagelsesbehandlere afsluttes programmet, og den normale eksekveringsstrøm afbrydes, når en undtagelse opstår.
Med undtagelse, der håndteres korrekt i programmet, kan det fortsætte med sin normale udførelse, selv når en undtagelse opstår.
Flere eksempler på undtagelser
En undtagelse er en begivenhed, der opstår, mens programmet kører, og det forstyrrer programudførelsen. Derfor slutter softwareproduktet pludseligt.
Når denne undtagelse opstår, opretter Java et objekt med en fejlmeddelelse og oplysninger om klassen. Dette er undtagelsesobjektet.
Hvorfor har vi brug for en undtagelse i Java?
Klasse ExcepDemo uden undtagelse:
public class ExcepDemo { public static void main(String[] args) { int i=5; int j=0; System.out.println(i/j); System.out.println('statement after division'); } }
PRODUKTION:
Klasse ExcepDemo med undtagelseshåndtering:
public class ExcepDemo { public static void main(String[] args) { // TODO Auto-generated method stub int i=5; int j=0; try { System.out.println(i/j); } catch(ArithmeticException ae) { System.out.println('wrong input'); } System.out.println('statement after division'); } }
PRODUKTION:
hvordan man opretter et computerprogram til begyndere
Prøv, fange og til sidst blokere:
- En undtagelse håndteres af try, catch block.
- Udsagn, der kan føre til undtagelser, er skrevet inde i prøveblokken.
- Når en undtagelse opstår, udføres udsagnene inde i fangstblokken. Hvis der ikke forekommer en undtagelse, udføres fangstblokken ikke.
- Uanset hvilken undtagelse der opstod eller ikke opstod, udføres den sidste blok.
Undtagelsestyper
Ukontrolleret undtagelse:
Da ukontrollerede undtagelser kan undgås ved korrekt programmering ( For eksempel. null pointer Exception, Arithmetic Exception) vil ikke have kontrolleret af compileren. Ukrydset undtagelse kastes ved kørsel.
Kontrolleret undtagelse:
- Kontrolleret undtagelse kontrolleres af kompilatoren, og det er obligatorisk at kaste eller håndtere undtagelsen.
- Denne undtagelse bruges til at adskille fejlhåndteringskoden fra den almindelige kode.
- Alle de kontrollerede undtagelser er grupperet, og det er nyttigt at differentiere problemerne.
Eksempel: java.io
import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class DemoExpChecked { public static void main(String[] args) { try { File file=new File('input.txt'); BufferedReader br = new BufferedReader(new FileReader(file)) ; String content; while ((content=br.readLine())!=null) { System.out.println(content); } br.close(); } catch(IOException e) { e.printStackTrace(); } } }
Fejl
En fejl kan opstå på grund af programlogiske fejl eller enhver hukommelse relateret til JVM-problem.
Eksempel: Hukommelse uden bunden fejl eller stackoverløbsfejl.
Kast og kast
Nøgleordet 'Kast' bruges til at kaste undtagelsen, mens nøgleordet 'kaster' bruges til at erklære undtagelsen.
Kast eksempelprogram:
public class Demothrow { String content ; public void driving(String c) { this.content=c; if (content.isEmpty()) { throw new NullPointerException('content is empty'); } else { System.out.println('content=='+content); } } public static void main(String[] args) { Demothrow dt=new Demothrow(); dt.driving(''); } }
Kaster eksempelprogram:
Kast bruges til at give oplysninger om, at denne metode kaster denne særlige undtagelse. Når du kalder den særlige metode, skal du håndtere denne undtagelse.
public class DemoThrows { int i=2,j=0; public void checkmethod () throws ArithmeticException{ System.out.println(i/j); } public static void main(String[] args) { DemoThrows d =new DemoThrows(); try { d.checkmethod(); } catch (ArithmeticException ae) { ae.printStackTrace(); } } }
Nøglepunkter, der skal bemærkes:
- Undtagelser er unormale hændelser, der opstår under programudførelsen, og det vil påvirke udførelsesflowet.
- En fejl er forskellig fra undtagelser. Fejl Eksempel: Hukommelse ude af fejl.
- Kontrollerede undtagelser kontrolleres under kompilering, og det er obligatorisk at håndtere denne afkrydsede undtagelse.
- En ikke-markeret undtagelse opstår under løbetiden.
Konklusion
Denne vejledning om undtagelseshåndtering i Java introducerede definitionen af undtagelser, undtagelseshåndtering og undtagelseshierarkiet i Java. Vi diskuterede også undtagelsesklassen i Java, der giver forskellige konstruktører og metoder til at få adgang til undtagelser.
Vi undersøgte en liste over de almindelige undtagelser, der forekommer i Java og så programmeringseksemplerne for den største undtagelse. Vi diskuterede også de største fejl, der opstår i et Java-program sammen med typerne af undtagelser og brugerdefinerede undtagelser.
=> Tjek ALLE Java-tutorials her.
Anbefalet læsning
- Top 10 selenundtagelser og hvordan man håndterer disse (nøjagtig kode)
- JDBC-undtagelseshåndtering - Sådan håndteres SQL-undtagelser
- Sådan håndteres undtagelser i SoapUI Groovy Scripts - SoapUI Tutorial # 11
- Java String med String Buffer og String Builder Tutorial
- Java-implementering: Oprettelse og udførelse af Java JAR-fil
- Java-tråde med metoder og livscyklus
- Java Virtual Machine: Hvordan JVM hjælper med at køre Java-applikationer
- Adgang modifikatorer i Java - vejledning med eksempler