try catch finally
En aquest tutorial, parlarem de diverses paraules clau que s’utilitzen a Java per al maneig d’excepcions, com ara Prova, Captura, Finalment, Llançament i Llançaments amb exemples:
En els nostres tutorials anteriors, hem vist els conceptes bàsics sobre el maneig d’excepcions a Java juntament amb les diverses excepcions admeses per la classe Java Exception. També hem debatut sobre l'excepció NullPointerException.
Podem incloure excepcions al nostre programa mitjançant l'ús de determinades paraules clau que es proporcionen a Java. Aquestes paraules clau defineixen diversos blocs de codi que faciliten la definició i el tractament d’excepcions.
=> Visiteu aquí la sèrie exclusiva de cursos de formació de Java.
Què aprendreu:
Prova, captura, finalment a Java
Les paraules clau següents s’utilitzen a Java per al tractament d’excepcions.
- Proveu-ho
- Captura
- Finalment
- Llançar
- Llançaments
La taula següent descriu breument aquestes paraules clau.
| Paraula clau | Descripció |
|---|---|
| Proveu-ho | Especifiquem el bloc de codi que pot donar lloc a l'excepció en un bloc especial amb una paraula clau 'Prova'. |
| Captura | Quan es planteja l'excepció, el programa l'ha de capturar. Això es fa mitjançant una paraula clau 'catch'. Per tant, un bloc de captures segueix el bloc try que genera una excepció. La paraula clau catch sempre s’ha d’utilitzar amb un intent. |
| Finalment | De vegades, tenim un codi important al nostre programa que cal executar independentment de si es genera o no l'excepció. Aquest codi es col·loca en un bloc especial que comença amb la paraula clau 'Finalment'. El bloc Final segueix el bloc Try-catch. |
| Llançar | La paraula clau 'llançar' s'utilitza per llançar l'excepció explícitament. |
| Llançaments | La paraula clau 'Llança' no genera cap excepció, sinó que s'utilitza per declarar excepcions. Aquesta paraula clau s'utilitza per indicar que es pot produir una excepció al programa o mètode. |
En aquest tutorial, parlarem detalladament de totes les paraules clau anteriors juntament amb els exemples de programació.
Proveu Bloquejar a Java
Sempre que estem escrivint un programa, hi pot haver un codi que sospitem que pot generar una excepció. Per exemple, podríem sospitar que hi pot haver una operació de 'divisió per zero' al codi que generi una excepció.
Aquest codi que pot generar una excepció s'inclou en un bloc amb la paraula clau 'prova'. Per tant, el bloc try conté el codi o el conjunt d’instruccions que poden generar una excepció.
La sintaxi general del bloc try és la següent:
try{ //set of statements that can raise exception } Per tant, si un programador pensa que certes sentències generaran excepcions, inclogui aquestes sentències en un bloc de prova. Tingueu en compte que quan es produeix una excepció en una sentència específica d'un bloc try, la resta del codi no s'executa.
Quan es produeix una excepció en un bloc try en una sentència particular, el control surt i el programa finalitza bruscament. Per evitar aquesta finalització brusca del programa, hauríem de 'gestionar' aquesta excepció. Aquest maneig es fa mitjançant la paraula clau 'catch'. Per tant, un bloc de prova sempre té un bloc de captures que el segueix.
Captura el bloc a Java
Utilitzem un bloc de captura per gestionar excepcions. Aquest és el bloc amb la paraula clau 'catch'. El bloc de captures segueix el bloc de prova.
Sempre que es produeix una excepció al bloc try, s'executa el codi del bloc catch que correspon a l'excepció.
La sintaxi general del bloc de captures és:
catch (Exception e){ //code to handle exception e }En general, l’excepció declarada ha de ser la classe principal de totes les excepcions, és a dir, Excepció. Però si hi ha més d’una excepció, també podem escriure tipus d’excepció específics o excepcions generades.
A continuació, analitzarem el bloc try-catch. Tingueu en compte que per a cada bloc de prova, podem tenir diversos blocs de captura.
Prova de capturar Java
A continuació es mostra la sintaxi general del bloc try-catch:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }El bloc try pot tenir diverses línies de codi que poden generar diverses excepcions. Cadascuna d’aquestes excepcions està gestionada per un bloc de captura independent.
El controlador d’excepcions genèric, objecte e de la classe Exception, pot gestionar totes les excepcions, però si volem gestionar excepcions específiques, és recomanable especificar el controlador d’excepcions genèric com a darrer bloc de captura.
Exemple de prova de captura de Java
Ara demostrem un bloc de prova a Java. Aquí, al bloc try, definim una operació de divisió. El divisor és zero. Així, l'enunciat que divideix els dos nombres planteja una excepció aritmètica. Tenim un bloc de captura que defineix un controlador per a l'excepció aritmètica.
A continuació es mostra un exemple de programa Java.
class Main { public static void main(String args()) { int val1, val2; try { //this block will contain statements that may raise exceptions System.out.println('Try Block:: Start'); val1 = 0; val2 = 25 / val1; System.out.println(val2); System.out.println('Try Block:: End'); } catch (ArithmeticException e) { //handler for ArithmeticException System.out.println('ArithmeticException :: Divide by Zero!!'); } System.out.println('Outside try-catch:: Rest of the code.'); } } Sortida
Preguntes i respostes a les entrevistes informàtiques freqüents
Obtenir diverses excepcions
Com ja s'ha esmentat, un bloc de prova pot contenir un codi que planteja més d'una excepció. En aquest cas, necessitarem més d’un bloc de captura per gestionar cada excepció. Un bloc de prova únic es pot seguir amb diversos blocs de captura. Cada bloc de captura gestionarà les excepcions independents.
En el cas de diversos blocs de captura, hem de recordar els punts següents:
- En un programa Java, en qualsevol moment, només es pot produir una excepció. A més, en qualsevol moment, només s’executa un bloc de captura.
- Els múltiples blocs de captura s’han d’ordenar de manera que el bloc de captura de l’excepció més específica hagi de ser primer i després el general.
Per exemple, si tenim ArithmeticException i General Exception, llavors el bloc de captura que maneja ArithmeticException vindrà primer seguit del bloc de captures que gestiona Exception.
L'exemple següent mostra diversos blocs de captura.
public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); myArray (5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } } Sortida
Al programa anterior, es planteja una excepció ArithmeticException que es troba al primer bloc de captures. Si no s'ha especificat aquest bloc de captura, l'excepció s'hauria propagat al bloc de captura generalitzat.
Modifiquem lleugerament el programa anterior perquè el bloc try plantegi dues excepcions. Ara vegem la sortida.
public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); System.out.println('Array element 10 : ' + myArray(10)); myArray(5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } } Sortida
Si veiem aquesta sortida, mostra que ArrayIndexOutOfBoundsException està sent llançada. Això es deu a que la instrucció que genera ArrayIndexOutOfBoundsException s'executa primer. Es produeix l'excepció i el control es dirigeix al bloc de captura corresponent.
Try-Catch imbricat
Un bloc de prova dins d’un altre bloc de prova s’anomena bloc de prova imbricat. Necessitem aquestes estructures en determinades situacions quan un fragment de codi contingut en un codi try pot ser tal que algunes línies plantegen certes excepcions i un altre fragment de codi planteja una excepció completament diferent.
En cas de blocs de prova imbricats, primer, s’executa el bloc de prova més intern i es gestiona l’excepció. Si el bloc de prova més intern no té un bloc de captura coincident, es propagarà un nivell fins al bloc de prova pare. D'aquesta manera, l'excepció es propaga cap amunt fins que es troba el gestor d'excepcions coincidents.
Si no hi ha cap gestor d’excepcions que coincideixi amb l’excepció, el programa s’acaba bruscament amb un missatge generat pel sistema.
A continuació es mostra la sintaxi general d’un bloc de prova imbricat:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Implantem un programa per demostrar el bloc de captures imbricat.
class Main{ public static void main(String args()){ //Main try block try{ //try block1 try{ System.out.println('Try Block1'); int num =15/0; System.out.println(num); } catch(ArithmeticException e1){ System.out.println('Block1 Exception: e1'); } //try block2 try{ System.out.println('Try Block2'); int num =100/0; System.out.println(num); } catch(ArrayIndexOutOfBoundsException e2){ System.out.println('Block2 Exception: e2'); } System.out.println('General statement after Block1 and Block2'); } catch(ArithmeticException e3){ System.out.println('Main Block Arithmetic Exception'); } catch(ArrayIndexOutOfBoundsException e4){ System.out.println('Main Block ArrayIndexOutOfBoundsException'); } catch(Exception e5){ System.out.println('Main Block General Exception'); } System.out.println('Code after Nested Try Block'); } } Sortida
Al programa anterior, tenim dos blocs de prova inclosos al bloc de prova principal. Tots dos blocs de prova interns tenen un codi que genera ArithmeticException. Però hem proporcionat un bloc de captura coincident només per al primer bloc i no per al segon bloc de prova.
Per tant, el segon bloc propaga la seva excepció al bloc principal de prova i després el maneja. Això es desprèn de la sortida.
Finalment Bloqueja a Java
Fins ara hem vist el bloc try-catch i try imbricat. Sabem que el codi que s'espera que generi l'excepció es col·loca en un bloc de prova. Quan es produeix una excepció, la resta del codi del bloc try no s'executa.
El programa finalitza bruscament si no es gestiona una excepció o el control es passa al controlador d'excepcions.
En aquesta situació, sorgeix la necessitat d’incloure un codi que s’ha d’executar independentment de si es produeix o no una excepció. Això significa que executarem un fragment de codi fins i tot quan es produeixi una excepció i també quan no es produeixi l'excepció.
Però a mesura que el bloc de prova surt després de plantejar-se l'excepció, no podem posar aquest codi al bloc de prova. De la mateixa manera, el bloc de captura té un controlador d’excepcions, de manera que tampoc no podem posar-lo al bloc de captures.
Per tant, necessitem un bloc separat que contingui un codi que s’executi independentment de si es produeix o no una excepció. Java proporciona un bloc 'finalment' que conté aquest tros de codi.
Per tant, un bloc finalment a Java pot contenir sentències crítiques que s’han d’executar al programa. L'execució d'aquestes declaracions s'hauria de dur a terme fins i tot quan es produeixi o no una excepció.
Per tant, posarem codi com a tancament de connexions, objectes de transmissió, etc. o qualsevol codi de neteja al bloc final perquè es puguin executar fins i tot si es produeix una excepció.
El bloc finalment a Java se sol posar després d’un bloc de prova o captura. Tingueu en compte que el bloc final no pot existir sense un bloc de prova. Quan el bloc finalment s’inclou amb try-catch, es converteix en un ' provar-atrapar-finalment ' bloc.
Podem ometre el bloc final en el codi de gestió d’excepcions. Això significa que finalment el bloc és opcional.
Si el bloc try no planteja cap excepció, el bloc final s'executarà després del bloc try. Si hi ha una excepció al bloc de prova, el control passarà primer al bloc de captura i després al bloc final.
Una excepció que es produeix al bloc finalment es comporta de la mateixa manera que qualsevol altra excepció. Fins i tot si el bloc try conté sentències return o sentències ramificades com break and continue, el bloc final encara s’executarà.
Tenint en compte aquests punts, anem endavant amb la sintaxi general i els exemples de bloc finalment.
La sintaxi general del bloc final és la següent:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Tot i que finalment el bloc sempre s’executa, hi ha certes situacions o casos en què no s’executa.
Aquests són els casos següents:
- Quan el fil està mort.
- Quan s’utilitza el mètode System.exit ().
- Quan es produeix una excepció al bloc final.
Implantem un parell de programes per demostrar el bloc final.
captures de pantalla de llocs web del passat
class Main { public static void main (String args()) { //try block try { System.out.println ('::Try Block::'); int data = 125 / 5; System.out.println ('Result:' + data); } //catch block catch (NullPointerException e) { System.out.println ('::Catch Block::'); System.out.println (e); } //finally block finally { System.out.println (':: Finally Block::'); System.out.println ('No Exception::finally block executed'); } System.out.println ('rest of the code...'); } } Sortida
El programa anterior mostra un bloc try-catch-finalment. Al bloc try, es realitza una operació vàlida i, per tant, no es produeix cap excepció. Per tant, el control no es passa per capturar de provar, sinó per bloquejar-lo finalment.
El següent programa és un altre exemple de bloc try-catch-finalment, però en aquest cas, l’excepció es produeix al bloc try quan realitzem una operació de divisió per zero. Així, el bloc final s’executa després de provar el bloc de captures.
class Main { public static void main(String args()) { //try block try{ System.out.println('::Try block::'); int num=67/0; System.out.println(num); } //catch block catch(ArithmeticException e){ System.out.println('::Catch block::'); System.out.println('ArithmeticException::Number divided by zero'); } //finally block finally{ System.out.println('::Finally block::'); } System.out.println('Rest of the code continues...'); } } Sortida
Llançar una excepció a Java
Java proporciona una paraula clau 'llançar' mitjançant la qual podem llançar explícitament les excepcions del codi. Per exemple, si comprovem les operacions aritmètiques i volem plantejar algunes excepcions després de comprovar els operands, ho podem fer mitjançant la paraula clau 'llançar'.
Mitjançant la paraula clau throw, podem llançar les excepcions marcades o no marcades. La paraula clau throw també s’utilitza per llançar excepcions personalitzades.
La sintaxi general de la paraula clau throw és:
throw exception; or throw new exception_class('error message'); A continuació es mostra un exemple de programa per demostrar la paraula clau throw.
public class Main{ static void validate_Age(int age){ //if specified age is <18, throw ArithmeticException if(age<18) throw new ArithmeticException('Not eligible to vote and drive!!'); else //print the message System.out.println('Eligible to vote and drive!!'); } public static void main(String args()){ //call validate_Age method validate_Age(10); System.out.println('rest of the code...'); } } Sortida
Al programa anterior, fem servir un mètode per validar l'edat. Si l'edat és<18, then an exception is thrown to indicate the age is not valid.
Clàusula de llançaments
Hem vist provar de bloquejar per declarar excepcions. Conté el codi que pot generar excepcions. Hi ha una altra manera de declarar una excepció i utilitza la paraula clau 'llança'.
La declaració d'excepció que utilitza la paraula clau 'throws' indica al programador que pot haver-hi una excepció després de la paraula clau 'throws' i el programador hauria de proporcionar el codi de controlador corresponent per a aquesta excepció per mantenir el flux normal del programa.
Tanmateix, es planteja la pregunta de per què necessitem una paraula clau 'llançaments' quan tenim un bloc de captures més fiable per declarar i gestionar excepcions?
Una de les raons és que augmenta el nombre d’excepcions que poden produir-se, el nombre de blocs de captura que gestiona les excepcions també augmenta, ja que un bloc de captura només pot gestionar una excepció.
De la mateixa manera, si hi ha molts mètodes en un programa i cada mètode té nombroses excepcions, el codi serà innecessàriament llarg i inmanejable.
Per tant, declarar una excepció amb throws paraula clau a la signatura del mètode i després gestionar la trucada del mètode mitjançant try-catch sembla ser una solució viable.
Un altre avantatge de declarar excepcions mitjançant la paraula clau throws és que estem obligats a gestionar les excepcions. Si no proporcionem un controlador per a una excepció declarada, el programa generarà un error.
La sintaxi general de la paraula clau throws és la següent:
return_type method_name() throws exception_class_name{ //method code } Implantem ara un programa Java per demostrar la paraula clau 'throws'.
En aquest programa, tenim una classe Example_throw en la qual tenim un mètode testMethod. A la signatura d’aquest mètode de prova, declarem dues excepcions IOException i Arithmetic Exception mitjançant la paraula clau throws. A continuació, a la funció principal, les excepcions llançades són gestionades pel bloc de captura.
import java.io.*; class Example_Throw { //declare exception using throws in the method signature void testMethod(int num) throws IOException, ArithmeticException{ if(num==1) throw new IOException('IOException Occurred'); else throw new ArithmeticException('ArithmeticException'); } }class Main{ public static void main(String args()){ try{ //this try block calls the above method so handle the exception Example_Throw obj=new Example_Throw(); obj.testMethod(1); }catch(Exception ex){ System.out.println(ex); } } }Sortida
Preguntes freqüents
Q # 1) Quan s'utilitzen els llançaments de llançament de VS try-catch a Java?
Resposta: La paraula clau 'llança' s'utilitza per declarar l'excepció amb la signatura del mètode. La paraula clau throw s'utilitza per llançar explícitament l'excepció. El bloc try-catch s’utilitza per manejar les excepcions llançades per altres.
Q # 2) Podem fer servir llançaments, provar i atrapar en un sol mètode?
Resposta: No, no es pot llançar l'excepció i captar-la amb el mateix mètode. L'excepció que es declara mitjançant llançaments s'ha de gestionar al mètode de trucada que crida al mètode que ha generat l'excepció.
P # 3) Què passa quan un bloc de captures llança una excepció?
Resposta: Quan es llança una excepció al bloc de captures, el programa detindrà l'execució. En cas que el programa hagi de continuar, ha d'haver-hi un bloc de captura de prova separat per gestionar l'excepció plantejada al bloc de captura.
Q # 4) Què és try-catch-finalment a Java?
Resposta: El bloc try-catch-finalment conté els tres blocs, és a dir, prova bloc, bloc bloc i finalment bloc.
El bloc de prova conté el codi que pot generar una excepció. El bloc de captures conté el controlador d’excepcions per a excepcions del bloc de prova. El bloc final conté el codi crític que s'executarà independentment de si s'ha produït o no l'excepció.
P # 5) Per fi, es pot bloquejar un try-catch?
Resposta: Sí, si tenim un codi de neteja que pot generar una excepció al bloc final, podem tenir un bloc de prova. Tot i això, sembla lleig.
Conclusió
En aquest tutorial, hem discutit les diverses paraules clau que s’utilitzen en el tractament d’excepcions a Java. Hem parlat de paraules clau com intentar, capturar, finalment, llançar i llançar.
El codi que possiblement generarà una excepció s'inclou al bloc try i catch proporciona el controlador de l'excepció. El bloc final executa el codi inclòs independentment de si es genera o no l'excepció. El bloc final segueix generalment el bloc try o try-catch.
Utilitzem la paraula clau throws per declarar excepcions amb el mètode signature i throw s’utilitza explícitament per llançar excepcions. Normalment fem servir paraules clau throw per generar excepcions personalitzades.
=> Consulteu la guia de formació Java perfecta aquí.
Lectura recomanada
- Excepcions de Java i tractament d’excepcions amb exemples
- Com gestionar l'excepció ArrayIndexOutOfBoundsEx a Java?
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java
- Gestió d’excepcions de JDBC: com gestionar les excepcions d’SQL
- Tutorial de maneig d'excepcions C # amb exemples de codi
- Guia completa del maneig d'excepcions PL SQL amb exemples
- Gestió d'excepcions a C ++
- Python Try Except - Excepció de manipulació de Python amb exemples