java exceptions exception handling with examples
Aquest tutorial de vídeo sobre excepcions de Java explica tot sobre el maneig d'excepcions a Java. Aprendràs sobre la jerarquia d’excepcions, els tipus, els mètodes de classe i molt més:
Quan executem programes Java, el comportament normal o el flux normal del programa s’interromp a causa d’alguns esdeveniments inesperats.
Per exemple, obrim un fitxer per llegir les dades. Quan s’executa la trucada Open file, trobem que falta el fitxer que intentem obrir. Això provoca la interrupció del flux normal del programa.
Aquest esdeveniment que afecta o interromp el flux normal del programa s’anomena “ Excepció '.
=> Visiteu aquí per explorar la sèrie de formació Java per a tothom.
Aquí teniu un tutorial de vídeo sobre com gestionar les excepcions de Java:
Què aprendreu:
Gestió d'excepcions a Java
Quan es produeix una excepció al programa, s'acaba l'execució del programa. Com que es tracta d’una finalització brusca, el sistema genera un missatge i el mostra. El missatge generat pel sistema pot ser críptic com alguns codis o no es pot llegir.
Per tant, l'usuari normal hauria d'entendre per què el programa va aturar l'execució bruscament, hauria de conèixer el motiu. És possible que els missatges generats pel sistema com a resultat de l'excepció no siguin útils. A Java, podem gestionar l'excepció i proporcionar missatges significatius a l'usuari sobre el problema.
Aquest tractament d'excepció, conegut habitualment com 'Gestió d'excepcions' és una de les característiques més destacades de la programació Java.
Raons per les quals es produeix l’excepció
Podem tenir diversos motius pels quals es poden produir excepcions. Si és una excepció relacionada amb l'entrada, el motiu pot ser que les dades d'entrada són incorrectes o no es poden llegir.
Si obtenim una excepció per a E / S de fitxers, és molt possible que els fitxers que tractem no existeixin. En algun altre moment, pot haver-hi errors com ara problemes de xarxa, la impressora no està disponible o no funciona, etc.
En un programa, a part d’excepcions, també rebem errors. Per tant, per gestionar les excepcions amb efectivitat, hem de ser conscients de les diferències entre l’error i una excepció.
Un error indica un problema més greu amb l’aplicació i l’aplicació no hauria d’intentar detectar-la. Al contrari, l'excepció és una condició que qualsevol aplicació raonable intentarà detectar.
Per tant, un error a l'aplicació és més greu i les aplicacions es bloquejaran quan es produeixin un error. D’altra banda, les excepcions es produeixen en el codi i el programador pot gestionar-les proporcionant accions correctives.
Què és el maneig d'excepcions?
El maneig d'excepcions a Java és un mecanisme mitjançant el qual es manté el flux normal de l'aplicació. Per fer-ho, fem servir un potent mecanisme per gestionar errors o excepcions en temps d'execució en un programa.
Una seqüència de codi que s'utilitza per gestionar l'excepció s'anomena 'Gestor d'excepcions'. Un controlador d’excepcions interroga el context en el moment en què es va produir l’excepció. Això vol dir que llegeix els valors de les variables que eren a l'abast mentre es produïa l'excepció i després restaura el programa Java per continuar amb el flux normal.
Avantatges de la manipulació d’excepcions
El principal avantatge de la gestió d'excepcions és que manté el flux normal de l'aplicació malgrat que es produeixi una excepció. Quan es produeix una excepció, el programa sol finalitzar bruscament.
Tenir un controlador d’excepcions en un programa no farà que el programa finalitzi bruscament. En canvi, un controlador d’excepcions s’assegura que totes les sentències del programa s’executin amb normalitat i que el flux del programa no es trenqui bruscament.
Jerarquia d’excepcions a Java
El diagrama següent mostra la jerarquia d’excepcions a Java. La classe java.lang.Throwable (descendent de la classe Object) és la classe arrel de Java Exception. Les classes Exception i Error es deriven d'aquesta classe.
La classe d’excepcions és la classe base de totes les altres excepcions.
A continuació es mostra una jerarquia de la classe Exception a Java que enumerarà totes les excepcions principals que un programador Java hauria de tenir en compte.
millor programari per controlar la temperatura de la CPU
Classe d'excepció a Java
Com es veu al diagrama de jerarquia, la classe Throwable té dues subclasses directes, és a dir, Excepció i Error. Les excepcions derivades d’una font externa es descriuen a la classe Exception.
La classe Exception declara els constructors iguals que la classe Throwable i la invocació de cada constructor també invoca la seva contrapart Throwable. La classe d'excepció no declara els seus mètodes, hereta els mètodes de classe Throwable.
A continuació es presenten els constructors i els mètodes que utilitza la classe Exception.
Constructors
constructor Descripció Excepció pública () Un constructor per defecte que construeix una nova excepció amb el missatge com a nul. Excepció pública (missatge de cadena) Constructor per construir una nova excepció amb el missatge donat. En aquest cas, la causa no s’inicialitza i es pot utilitzar una trucada posterior a Throwable.initCause (java.lang.Throwable) per inicialitzar la causa. Excepció pública (missatge de cadena, causa llançable) Construeix una nova excepció mitjançant un missatge i una causa determinats. Excepció pública (causa llançable) Construeix una nova excepció amb la causa donada i un missatge donat per (cause == null? Null: cause.toString ()) (que normalment conté la classe i el missatge detallat de causa). Excepció protegida (missatge de cadena, causa llançable, boolean enableSuppression, boolean writableStackTrace) Construeix una nova excepció amb el missatge, la causa, la supressió (activat o desactivat) i la traça de pila que es pot escriure (habilitada o desactivada).
Mètodes
| Mètode prototip | Descripció |
|---|---|
| public String getMessage () | Obteniu un missatge detallat sobre l'excepció que s'ha produït. |
| public Throwable getCause () | Obteniu la causa de l'excepció representada per un objecte llançable |
| public String toString () | Concatena el nom de la classe amb el resultat de getMessage () i retorna la cadena resultant. |
| public void printStackTrace () | Imprimeix el resultat de toString () i el contingut de la traça de la pila al flux de sortida d'errors, System.err. |
| public StackTraceElement () getStackTrace () | Obteniu cada element de la traça de la pila en forma de matriu. |
| public Thrillable fillInStackTrace () | Ompliu la traça de la pila amb la traça de pila actual. |
Exemple d’excepció
A continuació, presentem un programa Java per demostrar un exemple bàsic d’excepció. Aquí proporcionem una variable de cadena inicialitzada a un valor nul. Quan intentem imprimir aquesta variable, es genera una excepció, ja que el valor de la cadena no pot ser 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()); } } Sortida
Tipus d'excepcions a Java
Java admet tres tipus d’excepcions:
- Excepció marcada
- Excepció sense marcar
- error
En aquesta secció, analitzarem els tres tipus anteriors.
# 1) Excepció marcada
Algunes excepcions es comproven en el moment de la compilació quan es compila el codi. Són 'Excepcions verificades'. El programa Java genera un error de compilació quan detecta que el codi dins d’un programa és propens a errors.
Podem fer-nos càrrec dels errors de compilació generats per una excepció marcada gestionant les excepcions, incloure el codi en un bloc try-catch o utilitzar la paraula clau throws.
A la jerarquia d'Excepcions, la classe que hereta directament la classe Throwable com IOException, ClassNotFoundException, etc., està marcada com a excepció excepte per a les classes RuntimeException i Error. Són excepcions sense comprovar.
El programa Java següent mostra les excepcions marcades, FileNotFoundException i IOException. En aquest programa, intentem obrir un fitxer que no existeix i llegir-ne.
Com que el fitxer no existeix, el mètode de fitxer obert genera FileNotFoundException. A continuació, quan intentem llegir el contingut del fitxer i tancar-lo, els mètodes anomenats llancen 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(); } }Sortida
A la sortida anterior, com que no existeix el controlador d’excepcions, obtenim errors de compilació per a les excepcions comprovades.
Ara proporcionem una clàusula de llançaments per a aquest programa. Com que el pare principal de FileNotFoundException és IOException, només especificarem la IOException després de la clàusula throws.
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(); } }Sortida
Com es veu a la sortida, quan gestionem l'excepció, proporciona una sortida més significativa en lloc dels errors de compilació.
# 2) Excepció sense marcar
Les excepcions no marcades són les excepcions que es comproven en temps d'execució. Per tant, malgrat les excepcions, la compilació de programes tindrà èxit. La majoria de les excepcions sense comprovar es generen a causa de les dades incorrectes utilitzades al programa.
Les classes que hereten 'RuntimeException' són excepcions sense comprovar. Excepcions com ArrayIndexOutofBounds Exception, ArithmeticException, NullPOinterException, etc. són exemples d’excepcions sense comprovar.
El programa següent mostra una excepció sense verificar en temps d'execució que es produeix si es divideix un nombre per zero.
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); } }Sortida
Veiem que el programa es compila amb èxit i que ArithmeticException es llança en temps d'execució.
Exemples d'excepció sense comprovar:
- ArrayIndexOutOfBoundsException
- NullPointerException
- IllegalArgumentException
- NumberFormatException
A part de les dues excepcions anteriors, hi ha poques excepcions marcades com ara:
- SQLException
- InvocationTargetExecption
# 3) Error
L’error sol ser una situació irreversible i irrecuperable en un programa i, quan es produeix un error, els programes es bloquegen. Alguns dels exemples d’errors d’un programa són OutOfMemoryError, AssertionError i VirtualMachineError, etc.
La classe d'error hereta de la classe Throwable. L'error descriu una situació que no es pot gestionar i provoca un programa que es bloqueja.
Analitzem l’error OutOfMemory en aquesta secció com a exemple d’error.
Sabem que tots els objectes de Java s’assignen mitjançant el nou operador i s’emmagatzemen a l’emmagatzematge dinàmic. Quan l’emmagatzematge dinàmic queda sense memòria, la màquina virtual de Java (JVM) no pot assignar l’objecte. Al mateix temps, el recollidor d’escombraries no pot alliberar memòria. Aquesta situació dóna lloc a l'error OutOfMemory.
El OutOfMemoryError a Java es mostrarà com es mostra a continuació:
'exception in thread 'main' java.lang.outofmemoryerror: java heap space' La presència d'OutOfMemoryError en un programa significa que s'estan processant massa dades o que els objectes es mantenen massa temps. De vegades, també pot ser una biblioteca de tercers que consumeixi memòria.
Causes de l’error OutOfMemory
# 1) Espai Heap de Java
Si una aplicació té massa finalitzadors, els recollidors d’escombraries no recuperen immediatament els objectes de classe que tinguin el mètode Finalitzar, sinó que es posen a la cua per finalitzar-los més endavant. De vegades, la finalització no pot mantenir-se amb el temps i la memòria d’emmagatzematge dinàmic s’omple donant lloc a OutOfMemoryError.
Un altre motiu de l'OutOfMemoryError és que la mida de l'emmagatzematge dinàmic especificada pot ser insuficient per a l'aplicació.
El següent codi mostra l'OutOfMemoryError que es pot produir a causa d'una gran mida de dades declarada per a una matriu.
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); } } Sortida
# 2) Permgen Space
L’àrea de generació permanent de la memòria també es pot esgotar i pot generar un error OutOfMemory.
La mida de la regió PermGen s'estableix durant el llançament de JVM. Si l'usuari no defineix la mida, s'utilitzarà la mida per defecte específica de la plataforma.
Tot i que els dos anteriors solen ser les principals causes de l’aparició d’OutOfMemoryError, pot haver-hi altres causes com la mida de la matriu que supera el límit de màquina virtual, etc.
Llista d'excepcions a Java
A continuació es mostra una llista de les principals excepcions que es produeixen a Java. Hem proporcionat exemples de programació d'algunes d'aquestes excepcions. Tingueu en compte que són excepcions integrades admeses per Java.
# 1) ArithmeticException: Les anomalies aritmètiques com dividir per zero resulten en ArithmeticException.
El programa següent mostra l'aparició d'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'); } } }Sortida
# 2) ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException es genera quan s'accedeix a un element de matriu mitjançant un índex il·legal. L'índex utilitzat és superior a la mida de la matriu o és negatiu.
# 3) ClassNotFoundException: Si no es troba la definició de classe, es crea la ClassNotFoundException.
# 4) FileNotFoundException: FileNotFoundException es dóna quan el fitxer no existeix o no s’obre.
# 5) Excepció IOE: L'excepció IOE s'executa quan l'operació d'entrada-sortida falla o s'interromp.
# 6) Excepció interrompuda: Sempre que un fil s’està processant, dormint o esperant, s’interromp llançant InterruptedException.
# 7) NoSuchFieldException: Si una classe no conté un camp o variable especificat, llença NoSuchFieldException.
# 8) NoSuchMethodException: Quan no es troba el mètode al qual s’accedeix, es crea NoSuchMethodException.
# 9) NullPointerException: NullPointerException es genera quan es fa referència a un objecte nul. Aquesta és l'excepció més important i més comuna a Java.
# 10) NumberFormatException: Aquesta excepció es planteja quan un mètode no pot convertir una cadena en un format numèric.
# 11) RuntimeException: Qualsevol excepció que es produeix en temps d'execució és una excepció RuntimeException.
# 12) StringIndexOutOfBoundsException: L'excepció StringIndexOutOfBoundsException és generada per la classe String i indica que l'índex supera la mida de l'objecte String o és negatiu.
# 13) Excepció EOF: EOFException és una part del paquet java.io i es llença quan s’arriba al final del fitxer i es llegeix el fitxer.
# 14) IllegalArgumentException: IllegalArgumentException es genera quan es passen arguments il·legals o no vàlids al mètode. Per exemple, el format de dades és incorrecte, valor nul quan es requereix un valor nul o arguments fora del rang.
El programa Java següent mostra l'excepció IllegalArgumentException.
public class Main { int m; public static void setMarks(int marks) public static void main(String() args) { setMarks(45); setMarks(101); } }Sortida
Al programa anterior, la IllegalArgumentException es llança a la segona trucada per establir la funció setMarks on introduïm les marques que estan fora del rang (> 45).
# 15) InputMismatchException: InputMismatchException es llança quan la lectura d'entrada no coincideix amb un patró especificat. Per exemple, si el programa espera un sencer i llegeix un float, es crea la InputMismatchException.
# 16) NoSuchElementException: NoSuchElementException es llança quan no existeix el següent element al qual es accedeix.
Per exemple, a Enumeració, s’utilitza el mètode nextElement () per accedir al següent element de l’enumeració. Si l'element no existeix, es llença NoSuchElementException. La majoria de les col·leccions Java generen aquesta excepció.
El programa que es mostra a continuació ho demostra.
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(); } } Sortida
# 17) ConcurrentModificationException: ConcurrentModificationException sol ser generat per les classes Collection. Aquesta excepció es genera quan els objectes intenten modificar un recurs simultàniament.
Per exemple, un fil no pot modificar una col·lecció quan hi accedeix un altre fil. Si permetem dos fils, aquests dos accediran simultàniament a la col·lecció i hi haurà incoherències.
L'exemple següent mostra l'excepció 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); } } } Sortida
Al programa anterior, mentre s’imprimeix l’ArrayList, intentem suprimir un element alhora. Aquest és l'accés simultani i, per tant, es genera una excepció.
Excepcions personalitzades a Java
Fins ara hem debatut sobre totes les excepcions incorporades o proporcionades pel llenguatge Java. A part d’aquestes excepcions, també podem definir les nostres pròpies excepcions. S’anomenen excepcions personalitzades o excepcions definides per l’usuari.
Mitjançant excepcions personalitzades, podem definir les nostres excepcions segons les nostres necessitats.
L'exemple següent mostra l'excepció personalitzada que hem definit per a un valor enter.
//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'); } } Sortida
Preguntes freqüents
P # 1) Què vol dir per excepció?
Resposta: Un esdeveniment que es produeix durant l'execució d'un programa i que altera el flux d'execució normal del programa s'anomena Excepció. L'excepció és no desitjada i inesperada i pot produir-se a causa de factors externs o errors de programació.
Q # 2) Quina diferència hi ha entre Error i Excepció?
Resposta: Les excepcions són esdeveniments que interrompen el flux normal del programa. Podem gestionar excepcions al nostre programa i continuar amb el programa amb normalitat. Un error és un esdeveniment irrecuperable que no es pot gestionar i finalitza el programa.
P # 3) Què voleu dir amb Gestió d'excepcions?
Resposta: El procés d’especificació de la seqüència de passos d’un programa per gestionar l’excepció s’anomena Gestió d’excepcions. En proporcionar controladors d’excepcions en un programa, podem assegurar el flux normal del programa.
P # 4) Quins avantatges té Exception Handling a Java?
Resposta: Mitjançant el tractament d’excepcions podem mantenir el flux d’execució normal d’una aplicació. També podem propagar els errors a la pila de trucades quan proporcionem gestors d’excepcions.
Q # 5) Per a què serveix Exception Handling?
Resposta: No finalitzar el flux normal d’execució d’una aplicació és l’ús principal de tenir controladors d’excepcions en un programa. Sense gestors d’excepcions, el programa finalitzarà i el flux d’execució normal s’interromprà quan es produeixi una excepció.
Amb l'excepció que es tracta correctament del programa, pot continuar amb la seva execució normal fins i tot quan es produeixi una excepció.
Més exemples d'excepcions
Una excepció és un esdeveniment que es produeix mentre s’executa el programa i que interromp l’execució del programa. Per això, el producte de programari acabarà bruscament.
Quan es produeix aquesta excepció, Java crea un objecte amb un missatge d'error i informació sobre la classe. Aquest és l'objecte d'excepció.
Per què necessitem una excepció a Java?
Classe ExcepDemo sense excepció:
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'); } } 
SORTIDA:
Class ExcepDemo amb maneig d'excepcions:
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'); } } 
SORTIDA:
Proveu, atrapeu i finalment bloquegeu:
- Una excepció es gestiona mitjançant el bloc try, catch.
- Les sentències que poden generar excepcions s’escriuen dins del bloc try.
- Quan es produeixi una excepció, s'executaran les sentències dins del bloc de captura. Si no es produeix cap excepció, el bloc de captura no s'executarà.
- Independentment de si s’ha produït o no una excepció, s’executarà el bloc final.
Tipus d’excepció
Excepció sense marcar:
Com que les excepcions no verificades es poden evitar mitjançant la programació adequada ( Per exemple. null pointer Exception, Arithmetic Exception) no haurà estat comprovat pel compilador. L'excepció sense marcar es llançarà en temps d'execució.
Excepció marcada:
- El compilador comprovarà l'excepció marcada i serà obligatòria per llançar o gestionar l'excepció.
- Aquesta excepció s’utilitza per separar el codi de gestió d’errors del codi normal.
- Totes les excepcions comprovades s'agrupen i és útil per diferenciar els problemes.
Exemple: 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(); } } } 
Errors
Es pot produir un error a causa d’errors lògics del programa o de qualsevol memòria relacionada amb un problema de JVM.
Exemple: Memòria fora d'error vinculat o error de desbordament de pila.
Llançar i llançar
La paraula clau 'Throw' s'utilitza per generar l'excepció, mentre que la paraula clau 'throws' s'utilitza per declarar l'excepció.
Programa d'exemple de llançament:
millors eines del sistema per a Windows 10
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(''); } } 
Programa d'exemples de llançaments:
Els llançaments s’utilitzen per donar informació que aquest mètode genera aquesta excepció en particular. Quan truqueu a aquest mètode concret, heu de gestionar aquesta excepció.
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(); } } } 
Punts clau que cal tenir en compte:
- Les excepcions són esdeveniments anormals que es produeixen durant l'execució del programa i que afectaran el flux d'execució.
- Un error és diferent de les excepcions. Exemple d'errors: Memòria sense error.
- Les excepcions comprovades es comproven durant la compilació i és obligatori tractar aquesta excepció comprovada.
- Es produeix una excepció sense comprovar durant el temps d'execució.
Conclusió
Aquest tutorial sobre la gestió d'excepcions a Java va introduir la definició d'excepcions, la gestió d'excepcions i la jerarquia d'excepcions a Java. També vam discutir la classe d’excepcions a Java que proporciona diversos constructors i mètodes per accedir a excepcions.
Hem explorat una llista de les excepcions habituals que es produeixen a Java i hem vist els exemples de programació de l'excepció principal. També vam discutir els principals errors que es produeixen en un programa Java juntament amb els tipus d’excepcions i excepcions personalitzades.
=> Consulteu TOTS els tutorials de Java aquí.
Lectura recomanada
- Top 10 excepcions de seleni i com gestionar-les (codi exacte)
- Gestió d’excepcions de JDBC: com gestionar les excepcions d’SQL
- Com gestionar l'excepció en scripts SoapUI Groovy: tutorial SoapUI núm. 11
- Java String amb buffer de cadenes i tutorial de Generador de cadenes
- Desplegament de Java: creació i execució del fitxer JAR de Java
- Fils de Java amb mètodes i cicle de vida
- Màquina virtual Java: com ajuda JVM a executar aplicacions Java
- Modificadors d'accés a Java: tutorial amb exemples