Tractament d'excepcions en Java és un dels mitjans eficaços per gestionar els errors en temps d'execució de manera que es pugui preservar el flux normal de l'aplicació. La gestió d'excepcions de Java és un mecanisme per gestionar errors en temps d'execució com ClassNotFoundException, IOException, SQLException, RemoteException, etc.
Què són les excepcions de Java?
A Java, excepció és un esdeveniment no desitjat o inesperat, que es produeix durant l'execució d'un programa, és a dir, en temps d'execució, que interromp el flux normal de les instruccions del programa. Les excepcions poden ser detectades i gestionades pel programa. Quan es produeix una excepció dins d'un mètode, es crea un objecte. Aquest objecte s'anomena objecte d'excepció. Conté informació sobre l'excepció, com ara el nom i la descripció de l'excepció i l'estat del programa quan es va produir l'excepció.
Principals raons per les quals es produeix una excepció
- Entrada de l'usuari no vàlida
- Error del dispositiu
- Pèrdua de connexió a la xarxa
- Limitacions físiques (memòria fora del disc)
- Errors de codi
- Obrint un fitxer no disponible
Errors representen condicions irrecuperables com ara la màquina virtual Java (JVM) que s'esgota la memòria, les fuites de memòria, els errors de desbordament de la pila, la incompatibilitat de biblioteques, la recursivitat infinita, etc. Els errors solen estar fora del control del programador i no hem d'intentar gestionar els errors.
Diferència entre error i excepció
Parlem de la part més important que és la diferències entre error i excepció que és el següent:
- Error: Un error indica un problema greu que una aplicació raonable no hauria d'intentar detectar.
- Excepció: L'excepció indica condicions que una aplicació raonable podria intentar detectar.
Jerarquia d'excepcions
Tots els tipus d'excepció i error són subclasses de la classe Llançable , que és la classe base de la jerarquia. Una branca està encapçalada per Excepció . Aquesta classe s'utilitza per a condicions excepcionals que haurien d'aconseguir els programes d'usuari. NullPointerException és un exemple d'aquesta excepció. Una altra branca, Error és utilitzat pel sistema d'execució de Java ( JVM ) per indicar errors que tenen a veure amb el propi entorn d'execució (JRE). StackOverflowError és un exemple d'aquest error.
Jerarquia d'excepcions de Java
Tipus d'excepcions
Java defineix diversos tipus d'excepcions relacionades amb les seves diverses biblioteques de classes. Java també permet als usuaris definir les seves pròpies excepcions.
Les excepcions es poden classificar de dues maneres:
- Excepcions incorporades
- Excepció marcada
- Excepció no marcada
- Excepcions definides per l'usuari
Parlem de l'excepció enumerada anteriorment que és la següent:
1. Excepcions incorporades
Les excepcions integrades són les excepcions que estan disponibles a les biblioteques de Java. Aquestes excepcions són adequades per explicar determinades situacions d'error.
- Excepcions marcades: Les excepcions marcades s'anomenen excepcions en temps de compilació perquè el compilador les verifica en temps de compilació.
- Excepcions no marcades: Les excepcions no marcades són just oposades a les excepcions marcades. El compilador no comprovarà aquestes excepcions en temps de compilació. En paraules senzilles, si un programa llança una excepció no marcada, i fins i tot si no la gestionem ni la declarem, el programa no donaria cap error de compilació.
Nota: Per a l'excepció marcada o no marcada, vegeu Excepcions marcades i no marcades
java priorityqueue
2. Excepcions definides per l'usuari:
De vegades, les excepcions integrades a Java no poden descriure una situació determinada. En aquests casos, els usuaris també poden crear excepcions, que s'anomenen 'excepcions definides per l'usuari'.
El avantatges del maneig d'excepcions a Java són els següents:
- Provisió per a l'execució completa del programa
- Fàcil identificació del codi del programa i del codi de gestió d'errors
- Propagació d'errors
- Informe d'errors significatius
- Identificació de tipus d'error
Mètodes per imprimir la informació d'excepció:
1. printStackTrace()
Aquest mètode imprimeix informació de l'excepció en el format Nom de l'excepció: descripció de l'excepció, traça de pila.
Exemple:
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();> >}> >}> }> |
>
>
Sortida
java.lang.ArithmeticException: / by zero at GFG.main(File.java:10)>
2. toString()
El mètode toString() imprimeix la informació de l'excepció en el format Nom de l'excepció: descripció de l'excepció.
Exemple:
Java
//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());> >}> >}> }> |
>
>
Sortida
java.lang.ArithmeticException: / by zero>
3. getMessage()
El mètode getMessage() només imprimeix la descripció de l'excepció.
Exemple:
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());> >}> >}> }> |
>
>
Sortida
/ by zero>
Com gestiona JVM una excepció?
Gestió d'excepcions per defecte: Sempre que dins d'un mètode, si s'ha produït una excepció, el mètode crea un objecte conegut com a objecte d'excepció i el lliura al sistema en temps d'execució (JVM). L'objecte d'excepció conté el nom i la descripció de l'excepció i l'estat actual del programa on s'ha produït l'excepció. Crear l'objecte d'excepció i gestionar-lo al sistema en temps d'execució s'anomena llançar una excepció. Pot ser que hi hagi una llista dels mètodes que s'han cridat per arribar al mètode on s'ha produït una excepció. Aquesta llista ordenada de mètodes s'anomena Pila de trucades . Ara passarà el següent procediment.
- El sistema en temps d'execució cerca a la pila de trucades per trobar el mètode que conté un bloc de codi que pot gestionar l'excepció produïda. El bloc del codi s'anomena an Gestor d'excepcions .
- El sistema en temps d'execució comença a cercar des del mètode en què s'ha produït l'excepció i passa per la pila de trucades en l'ordre invers en què es van cridar els mètodes.
- Si troba un controlador adequat, li passa l'excepció que s'ha produït. Un controlador adequat significa que el tipus d'objecte d'excepció llançat coincideix amb el tipus d'objecte d'excepció que pot gestionar.
- Si el sistema en temps d'execució cerca tots els mètodes de la pila de trucades i no ha pogut trobar el controlador adequat, el sistema en temps d'execució lliura l'objecte d'excepció al gestor d'excepcions predeterminat , que forma part del sistema d'execució. Aquest controlador imprimeix la informació d'excepció en el format següent i finalitza el programa anormalment .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>
Mireu el diagrama següent per entendre el flux de la pila de trucades.
Il·lustració:
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());> >}> }> |
>
>
Sortida
Vegem un exemple que il·lustra com un sistema en temps d'execució cerca el codi de gestió d'excepcions adequat a la pila de trucades.
Exemple:
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());> >}> >}> }> |
>
>Sortida
/ by zero>
Com gestiona el programador una excepció?
Gestió d'excepcions personalitzada: El maneig d'excepcions de Java es gestiona mitjançant cinc paraules clau: provar , agafar , llançar , llançaments , i finalment . Breument, aquí és com funcionen. Les declaracions del programa que creieu que poden generar excepcions es troben dins d'un bloc try. Si es produeix una excepció dins del bloc try, es llança. El vostre codi pot detectar aquesta excepció (utilitzant el bloc catch) i gestionar-la d'alguna manera racional. Les excepcions generades pel sistema són llançades automàticament pel sistema d'execució de Java. Per llançar una excepció manualment, utilitzeu la paraula clau throw. Qualsevol excepció que s'elimini d'un mètode s'ha d'especificar com a tal mitjançant una clàusula throws. Qualsevol codi que s'hagi d'executar absolutament després que s'hagi completat un bloc try es posa en un bloc finally.
Consell: S'ha de passar controla el flux en try catch finalment bloqueja per a una millor comprensió.
Necessitat de la clàusula try-catch (gestió d'excepcions personalitzat)
Considereu el programa següent per entendre millor la clàusula try-catch.
Exemple:
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'>);> >}> }> |
>
>
Sortida
Explicació de la sortida: A l'exemple anterior, una matriu es defineix amb la mida, és a dir, només podeu accedir als elements de l'índex 0 al 3. Però intenteu accedir als elements de l'índex 4 (per error), és per això que està llançant una excepció. En aquest cas, JVM finalitza el programa anormalment . La declaració System.out.println(Hola, vull executar); mai executarà. Per executar-lo, hem de gestionar l'excepció mitjançant try-catch. Per tant, per continuar el flux normal del programa, necessitem una clàusula try-catch.
Com utilitzar la clàusula 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 }> Cal recordar alguns punts clau que són els següents:
- En un mètode, hi pot haver més d'una declaració que pot generar una excepció, així que poseu totes aquestes declaracions dins de les seves pròpies provar bloquejar i proporcionar un controlador d'excepcions independent dins dels seus agafar bloc per a cadascun d'ells.
- Si es produeix una excepció dins del provar bloc, aquesta excepció la gestiona el controlador d'excepcions associat. Per associar el controlador d'excepcions, hem de posar a agafar bloqueja després d'ell. Hi pot haver més d'un gestor d'excepcions. Cadascú agafar block és un controlador d'excepcions que gestiona l'excepció del tipus indicat pel seu argument. L'argument ExceptionType declara el tipus d'excepció que pot gestionar i ha de ser el nom de la classe que hereta del Llançable classe.
- Per a cada bloc try, hi pot haver zero o més blocs catch, però només un bloc final.
- El bloc final és opcional. Sempre s'executa tant si s'ha produït una excepció al bloc try o no. Si es produeix una excepció, s'executarà després intentar atrapar blocs. I si no es produeix una excepció, s'executarà després de provar bloc. El bloc finally a Java s'utilitza per posar codis importants com ara el codi de neteja, per exemple, tancar el fitxer o tancar la connexió.
- Si escrivim System.exit al bloc try, finalment el bloc no s'executarà.
El resum es mostra a través d'ajuda visual de la següent manera:
Articles relacionats:
- Tipus d'excepcions a Java
- Excepcions marcades i no marcades
- Throw-Throws en Java
Cursos Relacionats
Java Programming Foundation - Curs de ritme autònom
Trobeu el curs adequat per començar a aprendre Java Programming Foundation dels experts del sector amb anys d'experiència. Això Java Programming Foundation - Curs de ritme autònom cobreix els fonaments de la Llenguatge de programació Java, tipus de dades, operadors i control de flux, bucles, cadenes , i molt més. No més esperes! Comenceu a aprendre JAVA ara i convertiu-vos en un enginyer Java complet!