Tratarea excepțiilor în Java este unul dintre mijloacele eficiente de a gestiona erorile de rulare, astfel încât fluxul obișnuit al aplicației să poată fi păstrat. Java Exception Handling este un mecanism de gestionare a erorilor de rulare, cum ar fi ClassNotFoundException, IOException, SQLException, RemoteException etc.
Ce sunt excepțiile Java?
În Java, excepție este un eveniment nedorit sau neașteptat, care are loc în timpul execuției unui program, adică în timpul rulării, care perturbă fluxul normal al instrucțiunilor programului. Excepțiile pot fi capturate și gestionate de program. Când apare o excepție într-o metodă, aceasta creează un obiect. Acest obiect este numit obiect excepție. Conține informații despre excepție, cum ar fi numele și descrierea excepției și starea programului când a avut loc excepția.
Motive majore pentru care apare o excepție
- Intrare nevalidă de utilizator
- Eroare dispozitiv
- Pierderea conexiunii la rețea
- Limitări fizice (memorie în afara discului)
- Erori de cod
- Deschiderea unui fișier indisponibil
Erori reprezintă condiții irecuperabile, cum ar fi mașina virtuală Java (JVM) epuizarea memoriei, scurgeri de memorie, erori de supraîncărcare a stivei, incompatibilitate de bibliotecă, recursivitate infinită, etc. Erorile sunt de obicei dincolo de controlul programatorului și nu ar trebui să încercăm să gestionăm erorile.
Diferența dintre eroare și excepție
Să discutăm despre partea cea mai importantă, care este diferențele dintre eroare și excepție adica dupa cum urmeaza:
- Eroare: O eroare indică o problemă gravă pe care o aplicație rezonabilă nu ar trebui să încerce să o surprindă.
- Excepție: Excepția indică condiții pe care o aplicație rezonabilă ar putea încerca să le prindă.
Ierarhia excepțiilor
Toate tipurile de excepții și erori sunt subclase ale clasei Aruncabil , care este clasa de bază a ierarhiei. O filială este condusă de Excepție . Această clasă este utilizată pentru condiții excepționale pe care programele utilizatorului ar trebui să le prindă. NullPointerException este un exemplu de astfel de excepție. O altă ramură, Eroare este utilizat de sistemul de rulare Java ( JVM ) pentru a indica erori care au de-a face cu mediul de rulare în sine (JRE). StackOverflowError este un exemplu de astfel de eroare.
Ierarhia excepțiilor Java
Tipuri de excepții
Java definește mai multe tipuri de excepții care se referă la diferitele sale biblioteci de clasă. Java permite, de asemenea, utilizatorilor să-și definească propriile excepții.
Excepțiile pot fi clasificate în două moduri:
- Excepții încorporate
- Excepție bifată
- Excepție nebifată
- Excepții definite de utilizator
Să discutăm despre excepția definită mai sus, care este după cum urmează:
1. Excepții încorporate
Excepțiile încorporate sunt excepțiile care sunt disponibile în bibliotecile Java. Aceste excepții sunt potrivite pentru a explica anumite situații de eroare.
- Excepții verificate: Excepțiile verificate se numesc excepții la timp de compilare, deoarece aceste excepții sunt verificate la momentul compilării de către compilator.
- Excepții nebifate: Excepțiile nebifate sunt chiar opuse excepțiilor bifate. Compilatorul nu va verifica aceste excepții în timpul compilării. Cu cuvinte simple, dacă un program aruncă o excepție neverificată și chiar dacă nu am gestionat-o sau nu o declaram, programul nu ar da o eroare de compilare.
Notă: Pentru excepția bifată versus neverificată, consultați Excepții verificate vs. neverificate
2. Excepții definite de utilizator:
Uneori, excepțiile încorporate în Java nu sunt capabile să descrie o anumită situație. În astfel de cazuri, utilizatorii pot crea și excepții, care sunt numite „excepții definite de utilizator”.
The avantajele gestionării excepțiilor în Java sunt după cum urmează:
- Prevedere pentru finalizarea execuției programului
- Identificare ușoară a codului de program și a codului de gestionare a erorilor
- Propagarea erorilor
- Raportare semnificativă a erorilor
- Identificarea tipurilor de erori
Metode de imprimare a informațiilor de excepție:
1. printStackTrace()
Această metodă imprimă informații despre excepție în formatul Nume excepției: descrierea excepției, urmărirea stivei.
Exemplu:
Java
//program to print the exception information using printStackTrace() method> > import> java.io.*;> > class> GFG {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >e.printStackTrace();> >}> >}> }> |
>
>
Ieșire
java.lang.ArithmeticException: / by zero at GFG.main(File.java:10)>
2. toString()
Metoda toString() imprimă informații despre excepție în formatul Nume excepției: descrierea excepției.
Exemplu:
Java
Kat timpf
//program to print the exception information using toString() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.toString());> >}> >}> }> |
>
>
Ieșire
java.lang.ArithmeticException: / by zero>
3. getMessage()
Metoda getMessage() tipărește doar descrierea excepției.
Exemplu:
Java
//program to print the exception information using getMessage() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.getMessage());> >}> >}> }> |
>
>
Ieșire
/ by zero>
Cum gestionează JVM o excepție?
Gestionarea implicită a excepțiilor: Ori de câte ori în interiorul unei metode, dacă a apărut o excepție, metoda creează un obiect cunoscut sub numele de obiect de excepție și îl predă sistemului de rulare (JVM). Obiectul excepție conține numele și descrierea excepției și starea curentă a programului în care a avut loc excepția. Crearea obiectului de excepție și gestionarea acestuia în sistemul de rulare se numește aruncarea unei excepții. Ar putea exista o listă a metodelor care au fost apelate pentru a ajunge la metoda în care a apărut o excepție. Această listă ordonată de metode este numită Call Stack . Acum se va întâmpla următoarea procedură.
- Sistemul de rulare caută în stiva de apeluri pentru a găsi metoda care conține un bloc de cod care poate gestiona excepția apărută. Blocul codului se numește an Handler de excepții .
- Sistemul de rulare începe căutarea de la metoda în care a apărut excepția și trece prin stiva de apeluri în ordinea inversă în care au fost apelate metodele.
- Dacă găsește un handler adecvat, atunci îi transmite excepția apărută. Un handler adecvat înseamnă că tipul de obiect excepție aruncat se potrivește cu tipul de obiect excepție pe care îl poate gestiona.
- Dacă sistemul de rulare caută toate metodele din stiva de apeluri și nu ar fi putut găsi handlerul adecvat, atunci sistemul de rulare predă obiectul de excepție către handler implicit de excepții , care face parte din sistemul de rulare. Acest handler imprimă informațiile de excepție în următorul format și închide programul anormal .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>
Priviți diagrama de mai jos pentru a înțelege fluxul stivei de apeluri.
Ilustrare:
Java
// Java Program to Demonstrate How Exception Is Thrown> > // Class> // ThrowsExecp> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Taking an empty string> >String str =>null>;> >// Getting length of a string> >System.out.println(str.length());> >}> }> |
>
>
Ieșire
Să vedem un exemplu care ilustrează modul în care un sistem de rulare caută codul adecvat de gestionare a excepțiilor în stiva de apeluri.
Exemplu:
Java
// Java Program to Demonstrate Exception is Thrown> // How the runTime System Searches Call-Stack> // to Find Appropriate Exception Handler> > // Class> // ExceptionThrown> class> GFG {> > >// Method 1> >// It throws the Exception(ArithmeticException).> >// Appropriate Exception handler is not found> >// within this method.> >static> int> divideByZero(>int> a,>int> b)> >{> > >// this statement will cause ArithmeticException> >// (/by zero)> >int> i = a / b;> > >return> i;> >}> > >// The runTime System searches the appropriate> >// Exception handler in method also but couldn't have> >// found. So looking forward on the call stack> >static> int> computeDivision(>int> a,>int> b)> >{> > >int> res =>0>;> > >// Try block to check for exceptions> >try> {> > >res = divideByZero(a, b);> >}> > >// Catch block to handle NumberFormatException> >// exception Doesn't matches with> >// ArithmeticException> >catch> (NumberFormatException ex) {> >// Display message when exception occurs> >System.out.println(> >'NumberFormatException is occurred'>);> >}> >return> res;> >}> > >// Method 2> >// Found appropriate Exception handler.> >// i.e. matching catch block.> >public> static> void> main(String args[])> >{> > >int> a =>1>;> >int> b =>0>;> > >// Try block to check for exceptions> >try> {> >int> i = computeDivision(a, b);> >}> > >// Catch block to handle ArithmeticException> >// exceptions> >catch> (ArithmeticException ex) {> > >// getMessage() will print description> >// of exception(here / by zero)> >System.out.println(ex.getMessage());> >}> >}> }> |
>
>Ieșire
/ by zero>
Cum gestionează programatorul o excepție?
Gestionare personalizată a excepțiilor: Gestionarea excepțiilor Java este gestionată prin intermediul a cinci cuvinte cheie: încerca , captură , arunca , aruncări , și in cele din urma . Pe scurt, iată cum funcționează. Declarațiile de program care credeți că pot genera excepții sunt conținute într-un bloc try. Dacă apare o excepție în blocul try, aceasta este aruncată. Codul dvs. poate prinde această excepție (folosind catch block) și o poate gestiona într-un mod rațional. Excepțiile generate de sistem sunt aruncate automat de sistemul de rulare Java. Pentru a arunca manual o excepție, utilizați cuvântul cheie aruncare. Orice excepție care este eliminată dintr-o metodă trebuie specificată ca atare printr-o clauză throws. Orice cod care trebuie executat în mod absolut după încheierea unui bloc de încercare este pus într-un bloc final.
Bacsis: Trebuie să treci prin fluxul de control în încercarea de captură în cele din urmă bloc pentru o mai bună înțelegere.
Nevoia clauzei try-catch (tratare personalizată a excepțiilor)
Luați în considerare programul de mai jos pentru a înțelege mai bine clauza try-catch.
Exemplu:
bash else if
Java
// Java Program to Demonstrate> // Need of try-catch Clause> > // Class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Taking an array of size 4> >int>[] arr =>new> int>[>4>];> > >// Now this statement will cause an exception> >int> i = arr[>4>];> > >// This statement will never execute> >// as above we caught with an exception> >System.out.println(>'Hi, I want to execute'>);> >}> }> |
>
>
Ieșire
Explicația rezultatului: În exemplul de mai sus, o matrice este definită cu dimensiunea, adică puteți accesa elemente numai de la indexul 0 la 3. Dar încercați să accesați elementele de la indexul 4 (din greșeală), de aceea se aruncă o excepție. În acest caz, JVM închide programul anormal . Instrucțiunea System.out.println(Bună, vreau să execut); nu se va executa niciodată. Pentru a o executa, trebuie să gestionăm excepția folosind try-catch. Prin urmare, pentru a continua fluxul normal al programului, avem nevoie de o clauză try-catch.
Cum să folosiți clauza Try-catch?
try { // block of code to monitor for errors // the code you think can raise an exception } catch (ExceptionType1 exOb) { // exception handler for ExceptionType1 } catch (ExceptionType2 exOb) { // exception handler for ExceptionType2 } // optional finally { // block of code to be executed after try block ends }> Trebuie reținute anumite puncte cheie, care sunt următoarele:
- Într-o metodă, pot exista mai multe declarații care ar putea arunca o excepție, așa că puneți toate aceste declarații în propriile lor încerca blochează și oferă un handler de excepții separat în propriul lor captură bloc pentru fiecare dintre ele.
- Dacă apare o excepție în cadrul încerca bloc, acea excepție este gestionată de handlerul de excepții asociat cu ea. Pentru a asocia tratatorul de excepții, trebuie să punem a captură blocați după el. Pot exista mai mult de un handler de excepții. Fiecare captură block este un handler de excepție care gestionează excepția de la tipul indicat de argumentul său. Argumentul, ExceptionType declară tipul de excepție pe care o poate gestiona și trebuie să fie numele clasei care moștenește de la Aruncabil clasă.
- Pentru fiecare bloc de încercare, pot exista zero sau mai multe blocuri catch, dar unul singur bloc final.
- Blocul final este opțional. Este întotdeauna executat indiferent dacă a apărut o excepție în blocul try sau nu. Dacă apare o excepție, aceasta va fi executată după încercați să prindeți blocuri. Și dacă nu apare o excepție, atunci aceasta va fi executată după încerca bloc. Blocul final din Java este folosit pentru a pune coduri importante, cum ar fi codul de curățare, de exemplu, închiderea fișierului sau închiderea conexiunii.
- Dacă scriem System.exit în blocul try, atunci blocul final nu va fi executat.
Rezumatul este reprezentat prin intermediul unui ajutor vizual de mai jos, după cum urmează:
Articole similare:
- Tipuri de excepții în Java
- Excepții verificate vs. neverificate
- Aruncă-Aruncă în Java
Cursuri conexe
Java Programming Foundation – Curs cu ritm propriu
Găsiți cursul potrivit pentru a începe să învățați Java Programming Foundation de la experții din industrie cu ani de experiență. Acest Java Programming Foundation – Curs cu ritm propriu acoperă elementele fundamentale ale Limbajul de programare Java, tipuri de date, operatori și control al fluxului, bucle, șiruri , și mult mai mult. Gata cu așteptarea! Începeți să învățați JAVA acum și deveniți un inginer Java complet!