java exceptions exception handling with examples
Denna videohandledning om Java-undantag Förklarar allt om undantagshantering i Java. Du lär dig om undantagshierarki, typer, klassmetoder och mer:
När vi kör Java-program avbryts programmets normala beteende eller normala flöde på grund av några oväntade händelser.
Till exempel, vi öppnar en fil för att läsa data. När Open File-samtalet körs hittar vi den fil som vi försöker öppna saknas. Detta resulterar i att det normala flödet i programmet avbryts.
Denna händelse som påverkar eller avbryter programmets normala flöde kallas ” Undantag ”.
=> Besök här för att utforska Java Training Series för alla.
Här är en videohandledning om hantering av Java-undantag:
Vad du kommer att lära dig:
Undantagshantering i Java
När ett undantag inträffar i programmet avslutas programkörningen. Eftersom detta är en plötslig avslutning genererar systemet ett meddelande och visar det. Meddelandet som genereras av systemet kan vara kryptiskt som vissa koder eller oläsligt.
Således bör den normala användaren förstå varför programmet plötsligt stoppade körningen, han / hon borde veta orsaken. Systemgenererade meddelanden som ett resultat av undantag kanske inte är till hjälp. I Java kan vi hantera undantaget och ge meningsfulla meddelanden till användaren om problemet.
Denna hantering av undantag, allmänt känd som 'Undantagshantering' är en av de framträdande funktionerna i Java-programmering.
Anledningar till att undantaget ska inträffa
Vi kan ha olika anledningar på grund av vilka undantag som kan förekomma. Om det är ett undantag relaterat till inmatning kan orsaken vara att inmatningsdata är felaktiga eller oläsliga.
Om vi får ett undantag för fil I / O är det fullt möjligt att filerna vi har att göra med inte existerar. Vid en annan tid kan det finnas fel som nätverksproblem, skrivaren är inte tillgänglig eller fungerar etc.
I ett program, förutom undantag, får vi också fel. För att hantera undantagen effektivt måste vi därför vara medvetna om skillnaderna mellan fel och ett undantag.
Ett fel indikerar ett allvarligare problem med applikationen och applikationen bör inte försöka fånga den. Tvärtom är undantaget ett villkor som alla rimliga tillämpningar kommer att försöka fånga.
Således är ett fel i applikationen allvarligare och applikationerna skulle krascha när de stöter på ett fel. Undantag å andra sidan förekommer i kod och kan hanteras av programmeraren genom att tillhandahålla korrigerande åtgärder.
Vad är undantagshantering?
Undantagshanteringen i Java är en mekanism som använder det normala flödet av applikationen. För att göra detta använder vi en kraftfull mekanism för att hantera runtime-fel eller undantag i ett program.
En sekvens av kod som används för att hantera undantaget kallas “Exception handler”. En undantagshanterare frågar sammanhanget när undantaget inträffade. Detta innebär att den läser de variabla värden som var inom räckvidden medan undantaget inträffade och sedan återställer Java-programmet för att fortsätta med normalt flöde.
vad ska du använda när du felsöker en live nätverkskabel
Fördelar med undantagshantering
Den största fördelen med undantagshantering är att den bibehåller det normala flödet av applikationen trots att ett undantag förekommer. När ett undantag inträffar avslutas programmet vanligtvis plötsligt.
Att ha en undantagshanterare i ett program kommer inte att få programmet att avslutas plötsligt. Istället ser en undantagshanterare till att alla uttalanden i programmet körs normalt och att programflödet inte bryts plötsligt.
Undantagshierarki i Java
Nedanstående diagram visar undantagshierarkin i Java. Klassen java.lang.Throwable (härstammar från objektklassen) är rotklassen för Java Exception. Klasserna Undantag och fel härrör från denna klass.
Undantagsklass är basklassen för alla andra undantag.
Nedan följer en hierarki av Exception-klassen i Java som visar alla de viktigaste undantagen som en Java-programmerare bör vara medveten om.
Undantagsklass i Java
Som framgår av hierarkidiagrammet har klass Throwable två direkta underklasser, dvs. undantag och fel. Undantag som härrör från en extern källa beskrivs i klassen Undantag.
Undantagsklassen förklarar konstruktörerna som samma som kastbar klass och åberopande av varje konstruktör åberopar också sin kastbara motsvarighet. Undantagsklassen deklarerar inte sina metoder, den ärver kastbara klassmetoder.
De konstruktörer och metoder som Exception-klassen använder presenteras nedan.
Konstruktörer
Byggare Beskrivning offentligt undantag () En standardkonstruktör som konstruerar ett nytt undantag med meddelandet som null. offentligt undantag (strängmeddelande) Konstruktör för att konstruera ett nytt undantag med det givna meddelandet. I det här fallet initialiseras inte orsaken och ett efterföljande samtal till Throwable.initCause (java.lang.Trowable) kan användas för att initialisera orsaken. offentligt undantag (strängmeddelande, kastbar orsak) Konstruerar ett nytt undantag med hjälp av ett visst meddelande och orsak. offentligt undantag (kastbar orsak) Konstruerar ett nytt undantag med den angivna orsaken och ett meddelande från (orsak == null? Null: orsak.toString ()) (som vanligtvis innehåller klass- och detaljmeddelandet om orsak). skyddad undantag (strängmeddelande, kastbar orsak, boolean enableSuppression, boolean skrivbarStackTrace) Konstruerar ett nytt undantag med det angivna meddelandet, orsak, undertryckning (aktiverat eller inaktiverat) och den skrivbara stackspårningen (aktiverad eller inaktiverad).
Metoder
| Metodprototyp | Beskrivning |
|---|---|
| offentlig sträng getMessage () | Få ett detaljerat meddelande om undantaget som inträffade. |
| public Throwable getCause () | Få orsaken till undantaget som representeras av ett kastbart föremål |
| offentlig String toString () | Sammankopplar klassens namn med resultatet av getMessage () och returnerar den resulterande strängen. |
| public void printStackTrace () | Skriver ut resultatet av toString () och innehållet i stackspårning till felutmatningsströmmen, System.err. |
| offentlig StackTraceElement () getStackTrace () | Få varje element i stapelspåret i form av en matris. |
| public Throwable fillInStackTrace () | Fyll stackspåret med det aktuella stackspåret. |
Undantagsexempel
Därefter presenterar vi ett Java-program för att visa ett grundläggande undantagsexempel. Här tillhandahåller vi en strängvariabel initialiserad till ett nullvärde. När vi försöker skriva ut denna variabel kastas ett undantag eftersom strängvärdet inte kan vara null.
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 av undantag i Java
Java stöder tre typer av undantag:
- Kontrollerat undantag
- Okontrollerat undantag
- Fel
I detta avsnitt kommer vi att diskutera alla ovanstående tre typer.
# 1) Kontrollerat undantag
Vissa undantag kontrolleras vid sammanställningstidpunkten när koden sammanställs. Dessa är 'Kontrollerade undantag'. Java-programmet ger ett kompileringsfel när det upptäcker att koden i ett program är felbenägen.
Vi kan ta hand om kompileringsfelen som kastas genom kontrollerat undantag genom att hantera undantagen genom att antingen bifoga koden i ett försök-fångstblock eller använda nyckelordet.
I undantagshierarkin är den klass som ärvs direkt Throwable-klass som IOException, ClassNotFoundException, etc. alla kontrollerade undantag utom för klasserna RuntimeException och Error. Detta är okontrollerade undantag.
Följande Java-program visar kontrollerade undantag, FileNotFoundException och IOException. I det här programmet försöker vi öppna en icke-befintlig fil och läsa från den.
Eftersom filen inte finns, kastar metoden för öppen fil FileNotFoundException. Därefter, när vi försöker läsa innehållet i filen och stänga filen, kastar metodanropen 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 ovanstående utdata, eftersom undantagshanteraren är frånvarande, får vi kompileringsfel för kontrollerade undantag.
Låt oss nu ge en kastklausul för detta program. Eftersom FileNotFoundExcepts förälder är IOException, kommer vi bara att specificera IOException efter kastklausulen.
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 vi ser från utdata ger det mer meningsfull utdata när vi hanterar undantaget istället för kompileringsfelen.
# 2) Okontrollerat undantag
Okontrollerade undantag är de undantag som kontrolleras vid körningstid. Trots undantag kommer en sammanställning av program att lyckas. De flesta av de okontrollerade undantagen kastas på grund av dåliga data som används i programmet.
Klasserna som ärver 'RuntimeException' är okontrollerade undantag. Undantag som ArrayIndexOutofBounds Exception, ArithmeticException, NullPOinterException, etc. är exempel på okontrollerade undantag.
Följande program visar ett okontrollerat undantag för runtime som orsakas av att dela ett tal med noll.
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 att programmet har sammanställts framgångsrikt och sedan kastas ArithmeticException vid körning.
Exempel på okontrollerat undantag:
- ArrayIndexOutOfBoundsException
- NullPointerException
- IllegalArgumentException
- NumberFormatException
Bortsett från ovanstående två undantag finns det några fler kontrollerade undantag inklusive:
- SQLException
- InvocationTargetExecption
# 3) Fel
Fel är vanligtvis en oåterkallelig och oåterkallelig situation i ett program och när ett fel inträffar kraschar programmen. Några av exemplen på fel i ett program är OutOfMemoryError, AssertionError och VirtualMachineError, etc.
Felklass ärver från Throwable-klassen. Fel beskriver en situation som inte kan hanteras och resulterar i att ett program kraschar.
Låt oss diskutera OutOfMemory-felet i det här avsnittet som ett exempel på fel.
Vi vet att alla objekt i Java allokeras med den nya operatören och lagras på högen. När heapen tar slut i minnet kan Java Virtual Machine (JVM) inte allokera objektet. Samtidigt kan sopuppsamlaren inte frigöra något minne. Denna situation ger upphov till OutOfMemory-felet.
OutOfMemoryError i Java ser ut som visas nedan:
'exception in thread 'main' java.lang.outofmemoryerror: java heap space' Närvaron av OutOfMemoryError i ett program innebär att för mycket data bearbetas eller att objekten hålls för länge. Ibland kan det också vara ett tredjepartsbibliotek som förbrukar minne.
Orsaker till OutOfMemoryError
# 1) Java Heap Space
Om en applikation har för många slutbehandlare återvinns inte klassobjekten med Finalize-metoden av sopuppsamlaren omedelbart utan köas för slutförande vid ett senare tillfälle. Ibland kan slutförandet inte hänga med i tiden och heapminnet fylls upp vilket resulterar i OutOfMemoryError.
En annan anledning till OutOfMemoryError är att den angivna högstorleken kan vara otillräcklig för applikationen.
Följande kod visar OutOfMemoryError som kan uppstå på grund av en enorm datastorlek deklarerad för en matris.
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 genereringsområde i minnet kan också tömmas och kan generera OutOfMemory-fel.
Storleken på PermGen-regionen ställs in under JVM-lanseringen. Om användaren inte ställer in storleken används standardstorleken som är plattformsspecifik.
Även om ovanstående två vanligtvis är huvudorsakerna till OutOfMemoryError-förekomst, kan det finnas andra orsaker som arraystorlek som överskrider VM-gränsen etc.
Lista över undantag i Java
Nedan följer en lista över de viktigaste undantagen som förekommer i Java. Vi har gett programmeringsexempel för några av dessa undantag. Observera att dessa är inbyggda undantag som stöds av Java.
# 1) Aritmetikundantag: Aritmetiska avvikelser som dividerat med noll resulterar i ArithmeticException.
Nedanstående program visar förekomsten av 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 kastas när ett arrayelement nås med ett olagligt index. Det använda indexet är antingen bortom matrisens storlek eller är negativt.
# 3) ClassNotFoundException: Om klassdefinitionen inte hittas höjs ClassNotFoundException.
# 4) FileNotFoundException: FileNotFoundException ges när filen inte finns eller inte öppnas.
# 5) IOException: IOException kastas när ingångs-utgången misslyckas eller avbryts.
# 6) InterruptedException: När en tråd bearbetar eller sover eller väntar, avbryts den genom att kasta InterruptedException.
# 7) NoSuchFieldException: Om en klass inte innehåller ett angivet fält eller en variabel, kastar den NoSuchFieldException.
# 8) NoSuchMethodException: När metoden som nås inte hittas höjs NoSuchMethodException.
# 9) NullPointerException: NullPointerException höjs när ett null-objekt hänvisas. Detta är det viktigaste och vanligaste undantaget i Java.
# 10) NumberFormatException: Detta undantag tas upp när en metod inte kunde konvertera en sträng till ett numeriskt format.
# 11) RuntimeException: Alla undantag som inträffar vid körning är ett RuntimeException.
# 12) StringIndexOutOfBoundsException: StringIndexOutOfBoundsException kastas av strängklassen och indikerar att indexet ligger utanför storleken på strängobjektet eller är negativt.
# 13) EOFException: EOFException är en del av paketet java.io och kastas när filens slut nås och filen läses.
# 14) IllegalArgumentException: IllegalArgumentException kastas när olagliga eller ogiltiga argument skickas till metoden. Till exempel, fel dataformat, nullvärde när icke-null krävs eller argument utanför området.
Nedanstående Java-program visar IllegalArgumentException.
public class Main { int m; public static void setMarks(int marks) public static void main(String() args) { setMarks(45); setMarks(101); } }Produktion
I ovanstående program kastas IllegalArgumentException i det andra anropet till setMarks-funktionen där vi anger de märken som är utanför räckvidden (> 45).
# 15) InputMismatchException: InputMismatchException kastas när ingångsavläsningen inte matchar ett angivet mönster. Till exempel, om programmet förväntar sig ett heltal och läser en flottör, höjs InputMismatchException.
# 16) NoSuchElementException: NoSuchElementException kastas när nästa element som nås inte finns.
Till exempel, i Enumeration används metoden nextElement () för att komma åt nästa element i uppräkningen. Om elementet inte finns kastas NoSuchElementException. För det mesta slår Java Collections detta undantag.
Programmet nedan visar detta.
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
standard undernätmask för klass d
# 17) ConcurrentModificationException: ConcurrentModificationException kastas vanligtvis av samlingsklasser. Detta undantag kastas när objekten försöker ändra en resurs samtidigt.
Till exempel, en tråd kan inte ändra en samling när en annan tråd använder den. Om vi tillåter två trådar, kommer de två samtidigt att få tillgång till samlingen, och det blir inkonsekvenser.
Följande exempel visar 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
I det ovanstående programmet försöker vi radera ett element samtidigt som ArrayList skrivs ut. Detta är samtidig åtkomst och därmed kastas ett undantag.
Anpassade undantag i Java
Hittills har vi diskuterat alla undantag som är inbyggda eller tillhandahålls av Java-språket. Förutom dessa undantag kan vi också definiera våra egna undantag. Dessa kallas anpassade undantag eller användardefinierade undantag.
Med hjälp av anpassade undantag kan vi definiera våra undantag enligt våra behov.
Följande exempel visar det anpassade undantaget som vi definierade för ett heltalsvärde.
//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
Vanliga frågor
F # 1) Vad menar du med undantag?
Svar: En händelse som inträffar under körningen av ett program och stör det normala körningsflödet för programmet kallas Undantag. Undantaget är oönskat och oväntat och kan uppstå på grund av externa faktorer eller programmeringsfel.
F # 2) Vad är skillnaden mellan fel och undantag?
Svar: Undantag är händelser som stör programmets normala flöde. Vi kan hantera undantag i vårt program och fortsätta med programmet normalt. Ett fel är en oåterkallelig händelse som inte kan hanteras och avslutar programmet.
F # 3) Vad menar du med undantagshantering?
Svar: Processen för att specificera sekvensen av steg i ett program för att hantera undantaget kallas Exception Handling. Genom att tillhandahålla undantagshanterare i ett program kan vi säkerställa det normala flödet av programmet.
F # 4) Vilka är fördelarna med Exception Handling i Java?
Svar: Med hjälp av undantagshantering kan vi bibehålla det normala flödet av exekvering av en applikation. Vi kan också sprida felen upp i samtalsstacken när vi tillhandahåller undantagshanterare.
F # 5) Vad är användningen av Exception Handling?
Svar: Att inte avsluta det normala flödet av exekvering av en applikation är den största användningen av att ha undantagshanterare i ett program. Utan undantagshanterare kommer programmet att avslutas och det normala körningsflödet avbryts när ett undantag inträffar.
Med undantag hanteras ordentligt i programmet kan det fortsätta med sitt normala utförande även när ett undantag inträffar.
Fler exempel på undantag
Ett undantag är en händelse som inträffar medan programmet körs och det stör programkörningen. Därför slutar programvaruprodukten plötsligt.
När detta undantag uppstår skapar Java ett objekt med ett felmeddelande och information om klassen. Detta är undantagsobjektet.
Varför behöver vi ett undantag i Java?
hur man öppnar .bin-filer
Klass ExcepDemo utan undantag:
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:
Klass ExcepDemo med undantagshantering:
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:
Försök, fånga och slutligen blockera:
- Ett undantag hanteras av try, catch block.
- Uttalanden som kan leda till undantag skrivs inuti försöksblocket.
- När ett undantag inträffar kommer uttalandena i fångsten att utföras. Om ett undantag inte inträffar kommer inte fångstblocket att köras.
- Oavsett undantag inträffade eller inträffade kommer det slutliga blocket att köras.
Undantagstyper
Okontrollerat undantag:
Eftersom okontrollerade undantag kan undvikas genom korrekt programmering ( T.ex. nullpekare Exception, Arithmetic Exception) kommer inte att ha kontrollerats av kompilatorn. Okontrollerat undantag kastas vid körning.
Kontrollerat undantag:
- Kontrollerat undantag kommer att kontrolleras av kompilatorn och det är obligatoriskt att kasta eller hantera undantaget.
- Detta undantag används för att separera felhanteringskoden från den vanliga koden.
- Alla kontrollerade undantag är grupperade och det är användbart för att differentiera problemen.
Exempel: 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(); } } } 
Fel
Ett fel kan uppstå på grund av programlogiska misstag eller något minne relaterat till JVM-problem.
Exempel: Memory out of bound error eller stack overflow error.
Kasta och kasta
Nyckelordet “Kasta” används för att kasta undantaget, medan nyckelordet “kastar” används för att förklara undantaget.
Kasta exempelprogram:
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(''); } } 
Kastar exempelprogram:
Kast används för att ge information om att denna metod ger detta speciella undantag. När du ringer den specifika metoden måste du hantera det undantaget.
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(); } } } 
Viktiga punkter att notera:
- Undantag är onormala händelser som inträffar under programkörningen och det påverkar körningsflödet.
- Ett fel skiljer sig från undantagen. Fel Exempel: Minne av fel.
- Kontrollerade undantag kontrolleras under sammanställningen och det är obligatoriskt att hantera detta markerade undantag.
- Ett okontrollerat undantag inträffar under körningstiden.
Slutsats
Denna handledning om undantagshantering i Java introducerade definitionen av undantag, undantagshantering och undantagshierarkin i Java. Vi diskuterade också undantagsklassen i Java som ger olika konstruktörer och metoder för att komma åt undantag.
Vi undersökte en lista över de vanligaste undantagen som förekommer i Java och såg programmeringsexemplen för det största undantaget. Vi diskuterade också de största felen som uppstår i ett Java-program tillsammans med typerna av undantag och anpassade undantag.
=> Kontrollera ALLA Java-handledning här.
Rekommenderad läsning
- Topp 10 selenundantag och hur man hanterar dessa (exakt kod)
- JDBC Undantagshantering - Hur man hanterar SQL-undantag
- Hur man hanterar undantag i SoapUI Groovy Scripts - SoapUI-handledning # 11
- Java String med String Buffer och String Builder Tutorial
- Java-distribution: Skapande och utförande av Java JAR-fil
- Java-trådar med metoder och livscykel
- Java Virtual Machine: Hur JVM hjälper till att köra Java-applikationen
- Åtkomstmodifierare i Java - Handledning med exempel