Gestionarea excepțiilor în Java [cu exemple]
Publicat: 2020-11-12Excepțiile sunt evenimentul nedorit și neașteptat al unui program care nu este niciodată dorit de un programator, dar trebuie să se confrunte cu el de atâtea ori. Partea bună este că, cu limbajul orientat pe obiecte Java, este posibil să atenueze aceste evenimente nedorite printr-un concept numit „Manevrarea excepțiilor în Java ”. Nu repară excepția, ci oferă o modalitate alternativă de a o rezolva.
Pot exista multe motive pentru care să apară o excepție, inclusiv introducerea de date incorecte, defecțiunea hardware, eșecul conexiunii, serverul defect etc. Astfel, gestionarea excepțiilor este și va fi întotdeauna importantă în cursul învățării Java, deoarece ajută la asigurarea normalului. fluxul unui program în momentul în care are loc un eveniment neașteptat. Ignorarea excepțiilor poate duce la blocarea întregului software și poate duce la pierderea datelor.
Acum că ne-am făcut o idee despre excepții și gestionarea excepțiilor, haideți să ne aprofundăm în detaliu și să înțelegem, de asemenea, cum ajută Java în gestionarea excepțiilor.
Citiți: Excepție Gestionarea întrebărilor de interviu
Cuprins
Ce este gestionarea excepțiilor?
Un dezvoltator poate prezice excepțiile pe care o bucată de cod le poate arunca în timpul rulării. Unul dintre cele mai importante lucruri despre care mulți dintre cursanți devin ambigui este că toate excepțiile apar în timpul rulării și nu în momentul compilării. Java poate gestiona excepțiile numai în timpul rulării. Există anumite cuvinte cheie utilizate într-un program java pentru a crea un bloc de gestionare a excepțiilor.
java.lang.Exception este clasa părinte a tuturor claselor de excepție. Clasa Exception este o subclasă a clasei încorporate Throwable , care este o subclasă a clasei Object . În afară de Exception, Throwable are și o altă clasă, adică Error, care este o condiție anormală în timpul execuției programului, care nu poate fi gestionată de programele Java, care reprezintă principala diferență între Error și Exceptions.
După cum se arată în figura de mai sus, există în principal două categorii de excepții în Java. În secțiunea următoare, vom avea o privire detaliată asupra tipurilor de excepții în Java.
Excepții Java
Cauzele fundamentale ale excepțiilor sunt cele cauzate de programator sau de resursele fizice care au eșuat din anumite motive. Pe baza acestora, există în principal două categorii de excepții în Java, după cum urmează detaliile de mai jos:
- Excepție bifată
- Excepție nebifată
1. Excepție bifată
Excepțiile verificate sunt cunoscute sub denumirea de „excepții în timpul compilării”, deoarece sunt verificate în timpul compilării de către compilator pentru a monitoriza dacă excepția este gestionată de programator. Sistemul afișează apoi o eroare de compilare.
Câteva exemple de aceste excepții sunt IOException , Citiți: Idei de proiecte Java pentru începători
2. Excepție nebifată
Excepțiile nebifate sunt numite „Excepții de rulare”, deoarece apar în timpul rulării programului. Excepțiile neverificate sunt în mod normal ignorate în timpul compilării și nu sunt verificate.
Exemple de aceste excepții pot fi erorile dintr-un program, cum ar fi erorile logice sau utilizarea API-urilor incorecte care nu sunt sub controlul unui programator și necesită rectificarea unui administrator de sistem.
Excepție bifată vs neverificată
| Puncte de diferențiere | Excepție bifată Excepție nebifată Timp de manipulare | Verificate Excepțiile sunt verificate și tratate în momentul compilării. | Excepțiile nebifate nu sunt verificate în momentul compilării. |
| Identificarea excepției | Programul dă o eroare de compilare dacă o metodă aruncă o excepție verificată. | Programul se compilează bine, deoarece compilatorul nu poate verifica excepția. | |
| Moştenire | Ei nu moștenesc clasa RuntimeException. | Sunt subclasele clasei RuntimeException. | |
| Rolul dezvoltatorului | Poate fi gestionat de dezvoltatori. | Nu poate fi gestionat de dezvoltatori. |
Înțelegerea excepțiilor este pasul principal înainte de a le gestiona.
Cum ajută Java în gestionarea excepțiilor?
Acum că știm că există două tipuri de excepții în Java și anume, bifate și nebifate. Dacă o metodă aruncă o excepție verificată, aceasta ar trebui gestionată cu un bloc try-catch sau cuvântul cheie „throws” ar trebui declarat pentru a evita eroarea de compilare într-un program.
Exemplu de excepție verificată:
Acesta este un program de citire a unui fișier numit „Java”. Există trei locuri în care se aruncă o excepție bifată:
- FileInputStream: Folosit pentru specificarea căii și numelui fișierului FileNotFoundException .
- Metoda read(): Citirea conținutului fișierului aruncă IOException ;
iii. Metoda close(): Închiderea fluxului de intrare a fișierului aruncă IOException .
import java.io.*;
Exemplu de clasă {
public static void main ( Argumente șir [])
{
FileInputStream fis = null ;
/*Constructorul FileInputStream(Fișier nume de fișier)
* aruncă o excepție bifată FileNotFoundException */
fis = nou FileInputStream ( „B:/java.txt” );
int k;
/* Metoda read() a clasei FileInputStream aruncă
* o excepție verificată: IOException
*/
în timp ce (( k = fis.read() ) != – 1 )
{
Sistem . afară . print (( char )k);
}
/*Metoda close() închide fluxul de intrare al fișierului
* aruncă IOException*/
fis.close();
}
}
Ieșirea programului de mai sus:
Excepție găsită în firul „principal” java.lang. Eroare : probleme de compilare nerezolvate :
Excepție netratată FileNotFoundException găsită
Excepție netratată IOException găsită
Excepție netratată IOException găsită
Motivul acestei erori de compilare: nedeclararea sau gestionarea excepțiilor.
Trebuie citit: Proiecte Java GitHub
Metode de tratare a excepțiilor
Există două moduri prin care excepțiile pot fi gestionate, descrise mai jos:
Metoda 1: Declararea cuvântului cheie de excepție „aruncă”.
În programul de mai sus, toate cele trei excepții verificate sunt în interiorul metodei main(). Astfel, o modalitate de a evita eroarea de compilare este declararea excepției în metodă folosind cuvântul cheie „throws”. Deoarece IOException este o clasă părinte a FileNotFoundException, va acoperi și asta.
Program actualizat folosind cuvântul cheie throws:
import java.io.*;
Exemplu de clasă {
public static void main( String args[]) aruncă IOException
{
FileInputStream fis = null ;
fis = nou FileInputStream ( „B:/java.txt” );
int k;
în timp ce (( k = fis.read() ) != – 1 )
{
Sistem . afară . print (( char )k);
}
fis.close();
}
}
Ieșire:
Afișează conținutul fișierului pe ecran.
Metoda 2: Gestionați excepțiile folosind blocuri try-catch.
Aceasta este o abordare mai avansată a celei de mai sus și una dintre cele mai bune practici de gestionare a excepțiilor . Codul de program modificat, inclusiv blocurile try-catch, este după cum urmează:
import java.io.*;
Exemplu de clasă {
public static void main ( Argumente șir [])
{
FileInputStream fis = null ;
incearca {
fis = nou FileInputStream ( „B:/java.txt” );
} catch ( FileNotFoundException fnfe){
Sistem . out .println( „Fișierul nu este „ +
„prezent la calea specificată” );
}
int k;
incearca {
în timp ce (( k = fis.read() ) != – 1 )
{
Sistem . afară . print (( char )k);
}
fis.close();
} catch ( IOException ioe){
Sistem . out .println( „Eroare I/O „ +ioe);
}
}
}
Ieșire:
Acest cod va afișa în cele din urmă conținutul fișierului.
Exemplu de excepție neverificată
Excepțiile neverificate nu sunt verificate în momentul compilării. Programul nu va da o eroare de compilare dacă nu este declarată sau gestionată și va rula bine. Sarcina dezvoltatorului este de a anticipa condițiile care pot apărea în prealabil care provoacă astfel de excepții și de a le gestiona. Toate excepțiile neverificate sunt subclase ale clasei RuntimeException .
Exemplu de clasă {
public static void main ( Argumente șir [])
{
int num1= 10 ;
int num2= 0 ;
/* Împărțirea oricărui număr cu 0
* Va arunca ArithmeticException
*/
int res=num1/num2;
Sistem . out .println(res);
}
}
Codul se va compila cu succes cu acest cod, dar în timpul rulării, ar arunca ArithmeticException , deoarece excepțiile nebifate nu sunt verificate în timpul compilării. Să aruncăm o privire la un alt exemplu.
Exemplu de clasă {
public static void main ( Argumente șir [])
{
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
/* Matricea are 5 elemente, dar noi vrem
* afișați valoarea al 8-lea element. Va arunca
* Indicele matricei este în afara limitelor
*/
Sistem . out .println(arr[ 7 ]);
}
}
Acest cod se va compila cu succes, deoarece ArrayIndexOutOfBoundsException este o excepție nebifată.
Aici, pentru gestionarea excepțiilor neverificate, ar trebui să fie afișat utilizatorului un mesaj de excepție pe care dorește să-l afișeze, dar acesta nu există în matrice.
Gestionarea excepției codului de mai sus cu blocul try-catch
Exemplu de clasă {
public static void main( String args[]) {
incearca {
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
Sistem . out .println(arr[ 7 ]);
}
catch ( ArrayIndexOutOfBoundsException e){
Sistem . out .println( „Indexul specificat nu există” +
„în matrice”. );
}
}
}
Ieșire:
Indexul specificat nu există în matrice.
Notă: Pot exista mai multe blocuri catch în interiorul unui bloc try pentru gestionarea diferitelor excepții.
Metoda 3 : Folosirea cuvântului cheie „în final”.
Uneori se întâmplă ca un cod să fie executat chiar dacă apare o excepție. Aici este folosit cuvântul cheie final . Iată un cod tipic cu cuvântul cheie „finally”.
public int getPlayerScore(String playerFile)
aruncă FileNotFoundException {
Conținut scaner = nul;
încerca {
conținut = scaner nou ( fișier nou (fișier player));
return Integer.parseInt(contents.nextLine());
} in sfarsit {
if (conținut != null ) {
contents.close();
}
}
}
Aici, blocul final indică codul pe care vrem să îl ruleze Java atunci când încercăm să citim fișierul.
Chiar dacă se aruncă o excepție FileNotFoundException , Java va apela conținutul finally .
Putem gestiona excepția modificând codul după cum urmează:
public int PlayerScore(String playerRuns) {
Conținutul scanerului;
încerca {
conținut = scaner nou (fișier nou (playerRuns));
return Integer.parseInt(contents.nextLine());
} catch (FileNotFoundException noFile ) {
logger.warn(„Fișierul nu a fost găsit.”);
returnează 0;
} in cele din urma {
încerca {
if (conținut != null) {
contents.close();
}
} catch (IOException ioexc) {
logger.error(„Cititorul nu a putut fi închis.”, ioexc);
}
}
}
Concluzie
Cu acest articol, am încercat să parcurgem elementele de bază ale erorilor și excepțiilor și gestionarea excepțiilor în Java . Sperăm că acest ghid vă va oferi o idee bună despre această caracteristică unică pe care o oferă Java și acum puteți gestiona excepțiile și vă puteți recupera mai bine de la ele. Concluzie
Java oferă modalități de a gestiona excepțiile chiar de la cele specifice la cele generice. Excepțiile care nu pot fi anticipate cu ușurință în avans sunt numite excepții netratate. Captarea tuturor excepțiilor oferă echipei de dezvoltare vizibilitate asupra calității codului și a cauzelor principale ale erorilor care pot fi remediate rapid.
Dacă sunteți interesat să aflați mai multe despre Java, dezvoltarea stivă completă, consultați Diploma PG de la upGrad și IIIT-B în Dezvoltare software full-stack. Este îngrijit cu atenție pentru profesioniști și asigură sprijin în carieră la 360 de grade și include proiecte live la care să lucrați. Până la sfârșitul cursului, veți putea să proiectați și să construiți aplicații precum Swiggy, IMDB etc.
Nu sună interesant!-