try catch finally
In diesem Lernprogramm werden verschiedene in Java für die Ausnahmebehandlung verwendete Schlüsselwörter wie Try, Catch, finally, Throw und Throws anhand von Beispielen erläutert:
In unseren vorherigen Tutorials haben wir die Grundlagen der Ausnahmebehandlung in Java sowie die verschiedenen von der Java Exception-Klasse unterstützten Ausnahmen kennengelernt. Wir haben auch die NullPointerException ausführlich besprochen.
Wir können Ausnahmen in unser Programm aufnehmen, indem wir bestimmte Schlüsselwörter verwenden, die in Java bereitgestellt werden. Diese Schlüsselwörter definieren verschiedene Codeblöcke, die das Definieren und Behandeln von Ausnahmen erleichtern.
=> Besuchen Sie hier für die exklusive Java Training Tutorial-Reihe.
Was du lernen wirst:
Versuchen Sie, fangen Sie, schließlich in Java
Die folgenden Schlüsselwörter werden in Java für die Ausnahmebehandlung verwendet.
- Versuchen
- Fang
- Endlich
- Werfen
- Würfe
In der folgenden Tabelle werden diese Schlüsselwörter kurz beschrieben.
| Stichwort | Beschreibung |
|---|---|
| Versuchen | Wir geben den Codeblock, der die Ausnahme auslösen könnte, in einem speziellen Block mit dem Schlüsselwort 'Try' an. |
| Fang | Wenn die Ausnahme ausgelöst wird, muss sie vom Programm abgefangen werden. Dies erfolgt mit einem Schlüsselwort 'catch'. Ein catch-Block folgt also dem try-Block, der eine Ausnahme auslöst. Das Schlüsselwort catch sollte immer mit einem Versuch verwendet werden. |
| Endlich | Manchmal haben wir einen wichtigen Code in unserem Programm, der ausgeführt werden muss, unabhängig davon, ob die Ausnahme ausgelöst wird oder nicht. Dieser Code wird in einen speziellen Block eingefügt, der mit dem Schlüsselwort 'Endlich' beginnt. Der Block finally folgt dem Block Try-catch. |
| Werfen | Das Schlüsselwort 'throw' wird verwendet, um die Ausnahme explizit auszulösen. |
| Würfe | Das Schlüsselwort 'Throws' löst keine Ausnahme aus, wird jedoch zum Deklarieren von Ausnahmen verwendet. Dieses Schlüsselwort wird verwendet, um anzuzeigen, dass im Programm oder in der Methode eine Ausnahme auftreten kann. |
In diesem Tutorial werden alle oben genannten Schlüsselwörter zusammen mit den Programmierbeispielen ausführlich erläutert.
Versuchen Sie Block In Java
Wann immer wir ein Programm schreiben, kann es einen Code geben, von dem wir vermuten, dass er eine Ausnahme auslöst. Zum Beispiel, Wir könnten vermuten, dass der Code eine Operation „Division durch Null“ enthält, die eine Ausnahme auslöst.
Dieser Code, der möglicherweise eine Ausnahme auslöst, ist in einem Block mit dem Schlüsselwort 'try' eingeschlossen. Der try-Block enthält also den Code oder eine Reihe von Anweisungen, die eine Ausnahme auslösen können.
Die allgemeine Syntax des try-Blocks lautet wie folgt:
try{ //set of statements that can raise exception } Wenn ein Programmierer der Meinung ist, dass bestimmte Anweisungen Ausnahmen auslösen, schließen Sie diese Anweisungen in einen try-Block ein. Beachten Sie, dass der Rest des Codes nicht ausgeführt wird, wenn bei einer bestimmten Anweisung in einem try-Block eine Ausnahme auftritt.
Wenn eine Ausnahme in einem try-Block bei einer bestimmten Anweisung auftritt, wird die Steuerung deaktiviert und das Programm wird abrupt beendet. Um diese abrupte Beendigung des Programms zu verhindern, sollten wir diese Ausnahme „behandeln“. Diese Behandlung erfolgt mit dem Schlüsselwort 'catch'. Ein try-Block hat also immer einen catch-Block.
Catch Block In Java
Wir verwenden einen catch-Block, um Ausnahmen zu behandeln. Dies ist der Block mit dem Schlüsselwort 'catch'. Der catch-Block folgt dem try-Block.
Immer wenn im try-Block eine Ausnahme auftritt, wird der Code im catch-Block ausgeführt, der der Ausnahme entspricht.
Die allgemeine Syntax des catch-Blocks lautet:
catch (Exception e){ //code to handle exception e }Im Allgemeinen muss die deklarierte Ausnahme die übergeordnete Klasse aller Ausnahmen sein, d. H. Ausnahme. Wenn es jedoch mehr als eine Ausnahme gibt, können wir auch bestimmte Ausnahmetypen oder generierte Ausnahmen schreiben.
Als nächstes werden wir den Try-Catch-Block diskutieren. Beachten Sie, dass wir für jeden try-Block mehrere catch-Blöcke haben können.
Try-Catch Java
Die allgemeine Syntax des Try-Catch-Blocks ist unten dargestellt:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Der try-Block kann mehrere Codezeilen enthalten, die mehrere Ausnahmen auslösen können. Jede dieser Ausnahmen wird von einem unabhängigen Catch-Block behandelt.
Der generische Ausnahmehandler, Objekt e der Exception-Klasse, kann alle Ausnahmen behandeln. Wenn wir jedoch bestimmte Ausnahmen behandeln möchten, ist es ratsam, den generischen Ausnahmehandler als letzten catch-Block anzugeben.
Java Try Catch Beispiel
Lassen Sie uns nun einen Try-Catch-Block in Java demonstrieren. Hier im try-Block definieren wir eine Divisionsoperation. Der Divisor ist Null. Somit löst die Aussage, die die beiden Zahlen teilt, eine arithmetische Ausnahme aus. Wir haben einen catch-Block, der einen Handler für die arithmetische Ausnahme definiert.
Im Folgenden finden Sie ein Beispiel für ein Java-Programm.
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.'); } } Ausgabe
So öffnen Sie Bin-Dateien unter Windows 10
Mehrere Ausnahmen abfangen
Wie bereits erwähnt, kann ein try-Block einen Code enthalten, der mehr als eine Ausnahme auslöst. In diesem Fall benötigen wir mehr als einen catch-Block, um jede Ausnahme zu behandeln. Auf einen einzelnen Try-Block können mehrere Catch-Blöcke folgen. Jeder catch-Block behandelt die unabhängigen Ausnahmen.
Bei mehreren Fangblöcken müssen wir die folgenden Punkte beachten:
- In einem Java-Programm kann zu jedem Zeitpunkt nur eine Ausnahme auftreten. Außerdem wird zu jedem Zeitpunkt nur ein Fangblock ausgeführt.
- Die mehreren Fangblöcke sollten so angeordnet werden, dass der Fangblock für die spezifischste Ausnahme zuerst und dann der allgemeine kommt.
Zum Beispiel, Wenn wir ArithmeticException und General Exception haben, wird der Catch-Block, der ArithmeticException behandelt, zuerst gefolgt von der Catch-Block-Handling-Exception.
Das folgende Beispiel zeigt mehrere Fangblöcke.
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'); } } Ausgabe
Im obigen Programm wird eine ArithmeticException ausgelöst, die im ersten catch-Block abgefangen wird. Wenn dieser catch-Block nicht angegeben worden wäre, hätte sich die Ausnahme auf den verallgemeinerten catch-Block übertragen.
Lassen Sie uns das obige Programm leicht modifizieren, sodass der try-Block zwei Ausnahmen auslöst. Lassen Sie uns nun die Ausgabe sehen.
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'); } } Ausgabe
Wenn diese Ausgabe angezeigt wird, wird ArrayIndexOutOfBoundsException ausgelöst. Dies liegt daran, dass die Anweisung, die ArrayIndexOutOfBoundsException auslöst, zuerst ausgeführt wird. Die Ausnahme wird ausgelöst und die Steuerung geht zum entsprechenden Catch-Block.
Verschachtelter Try-Catch
Ein try-Block in einem anderen try-Block wird als verschachtelter try-Block bezeichnet. Wir benötigen solche Strukturen in bestimmten Situationen, in denen ein in einem Versuchscode enthaltener Code so sein kann, dass einige Zeilen bestimmte Ausnahmen auslösen und ein anderer Code eine völlig andere Ausnahme auslöst.
Bei verschachtelten Try-Blöcken wird zuerst der innerste Try-Block ausgeführt und die Ausnahme behandelt. Wenn der innerste try-Block keinen passenden catch-Block hat, wird er eine Ebene bis zu seinem übergeordneten try-Block weitergegeben. Auf diese Weise wird die Ausnahme nach oben weitergegeben, bis ein passender Ausnahmebehandler gefunden wird.
Wenn es keinen Ausnahmebehandler gibt, der mit der Ausnahme übereinstimmt, wird das Programm abrupt mit einer vom System generierten Nachricht beendet.
Die allgemeine Syntax eines verschachtelten try-Blocks ist unten angegeben:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Implementieren wir ein Programm, um den verschachtelten Try-Catch-Block zu demonstrieren.
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'); } } Ausgabe
Im obigen Programm sind zwei Try-Blöcke im Haupt-Try-Block enthalten. Beide inneren Try-Blöcke haben einen Code, der ArithmeticException auslöst. Wir haben jedoch nur für den ersten Block und nicht für den zweiten try-Block einen passenden catch-Block bereitgestellt.
Daher gibt der zweite Block seine Ausnahme an den Hauptversuchsblock weiter und behandelt sie dann. Dies geht aus der Ausgabe hervor.
Schließlich in Java blockieren
Bisher haben wir den Try-Catch- und den verschachtelten Try-Block gesehen. Wir wissen, dass der Code, von dem erwartet wird, dass er die Ausnahme auslöst, in einen try-Block gestellt wird. Wenn eine Ausnahme auftritt, wird der Rest des Codes im try-Block nicht ausgeführt.
Entweder wird das Programm abrupt beendet, wenn eine Ausnahme nicht behandelt wird, oder die Steuerung wird an den Ausnahmebehandler übergeben.
In einer solchen Situation besteht die Notwendigkeit, einen Code aufzunehmen, der ausgeführt werden soll, unabhängig davon, ob eine Ausnahme auftritt oder nicht. Dies bedeutet, dass wir einen Code ausführen, selbst wenn eine Ausnahme auftritt und auch wenn die Ausnahme nicht auftritt.
Da der try-Block nach dem Auslösen der Ausnahme beendet wird, können wir diesen Code nicht in den try-Block einfügen. In ähnlicher Weise verfügt der catch-Block über einen Ausnahmebehandler, sodass wir diesen nicht auch in den catch-Block einfügen können.
Daher benötigen wir einen separaten Block, der einen Code enthält, der unabhängig davon ausgeführt wird, ob eine Ausnahme auftritt oder nicht. Java bietet einen 'finally' -Block, der diesen Code enthält.
Daher kann ein finally-Block in Java kritische Anweisungen enthalten, die im Programm ausgeführt werden sollen. Die Ausführung dieser Anweisungen sollte auch dann erfolgen, wenn eine Ausnahme auftritt oder nicht.
Daher werden wir Code wie das Schließen von Verbindungen, das Streamen von Objekten usw. oder einen Bereinigungscode in den finally-Block einfügen, damit sie auch dann ausgeführt werden können, wenn eine Ausnahme auftritt.
Der finally-Block in Java wird normalerweise nach einem try- oder catch-Block gesetzt. Beachten Sie, dass der finally-Block ohne einen try-Block nicht existieren kann. Wenn der finally-Block in try-catch enthalten ist, wird er zu einem „ versuchen Sie es endlich ' Block.
Wir können den finally-Block im Ausnahmebehandlungscode überspringen. Dies bedeutet, dass der endgültige Block optional ist.
Wenn der try-Block keine Ausnahme auslöst, wird der finally-Block nach dem try-Block ausgeführt. Wenn der try-Block eine Ausnahme enthält, wird die Steuerung zuerst an den catch-Block und dann an den finally-Block übergeben.
Eine im finally-Block auftretende Ausnahme verhält sich wie jede andere Ausnahme. Selbst wenn der try-Block eine return-Anweisung oder Verzweigungsanweisungen wie break and continue enthält, wird der finally-Block dennoch ausgeführt.
Unter Berücksichtigung dieser Punkte fahren wir mit der allgemeinen Syntax und den Beispielen für finally block fort.
Die allgemeine Syntax des finally-Blocks lautet wie folgt:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Obwohl der Block schließlich immer ausgeführt wird, gibt es bestimmte Situationen oder Fälle, in denen er nicht ausgeführt wird.
Beispiel Testfälle für Versicherungsanträge
Dies sind die folgenden Fälle:
- Wenn der Faden tot ist.
- Wenn die System.exit () -Methode verwendet wird.
- Wenn im finally-Block eine Ausnahme auftritt.
Lassen Sie uns einige Programme implementieren, um den finally-Block zu demonstrieren.
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...'); } } Ausgabe
Das obige Programm zeigt einen Try-Catch-finally-Block. Im try-Block wird eine gültige Operation ausgeführt und daher wird keine Ausnahme ausgelöst. Daher wird die Steuerung nicht übergeben, um vom Versuch zu fangen, sondern um schließlich zu blockieren.
Das folgende Programm ist ein weiteres Beispiel für den Try-Catch-finally-Block. In diesem Fall wird die Ausnahme jedoch im Try-Block ausgelöst, wenn eine Operation zum Teilen durch Null ausgeführt wird. Somit wird der finally-Block nach dem Versuch ausgeführt, den catch-Block auszuführen.
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...'); } } Ausgabe
Eine Ausnahme in Java auslösen
Java bietet ein Schlüsselwort 'throw', mit dem wir die Ausnahmen im Code explizit auslösen können. Zum Beispiel, Wenn wir arithmetische Operationen überprüfen und nach dem Überprüfen von Operanden einige Ausnahmen auslösen möchten, können wir dies mit dem Schlüsselwort 'throw' tun.
Mit dem Schlüsselwort throw können wir die aktivierten oder nicht aktivierten Ausnahmen auslösen. Das Schlüsselwort throw wird auch verwendet, um benutzerdefinierte Ausnahmen auszulösen.
Die allgemeine Syntax des Schlüsselworts throw lautet:
throw exception; or throw new exception_class('error message'); Im Folgenden finden Sie ein Beispielprogramm zur Demonstration des Schlüsselworts 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...'); } } Ausgabe
Im obigen Programm verwenden wir eine Methode zur Validierung des Alters. Wenn das Alter ist<18, then an exception is thrown to indicate the age is not valid.
Wirft Klausel
Wir haben versucht, Ausnahmen zu deklarieren. Es enthält den Code, der Ausnahmen auslösen kann. Es gibt eine andere Möglichkeit, eine Ausnahme zu deklarieren, und es wird das Schlüsselwort 'throw' verwendet.
Die Ausnahmeerklärung mit dem Schlüsselwort 'throw' teilt dem Programmierer mit, dass nach dem Schlüsselwort 'throw' möglicherweise eine Ausnahme angegeben ist, und der Programmierer sollte den entsprechenden Handlercode für diese Ausnahme bereitstellen, um den normalen Programmfluss aufrechtzuerhalten.
Es stellt sich jedoch die Frage, warum wir ein Schlüsselwort 'throw' benötigen, wenn wir einen zuverlässigeren Try-Catch-Block zum Deklarieren und Behandeln von Ausnahmen haben.
Ein Grund dafür ist, dass mit zunehmender Anzahl möglicherweise auftretender Ausnahmen auch die Anzahl der Catch-Blöcke, die Ausnahmen behandeln, zunimmt, da ein Catch-Block nur eine Ausnahme behandeln kann.
Wenn ein Programm viele Methoden enthält und jede Methode zahlreiche Ausnahmen aufweist, wird der Code unnötig lang und nicht mehr verwaltbar.
Das Deklarieren einer Ausnahme mit dem Schlüsselwort throw in der Methodensignatur und das anschließende Behandeln des Methodenaufrufs mit try-catch scheint daher eine praktikable Lösung zu sein.
Ein weiterer Vorteil der Deklaration von Ausnahmen mit dem Schlüsselwort throw besteht darin, dass wir gezwungen sind, die Ausnahmen zu behandeln. Wenn wir keinen Handler für eine deklarierte Ausnahme bereitstellen, gibt das Programm einen Fehler aus.
Die allgemeine Syntax des Schlüsselworts throw lautet wie folgt:
return_type method_name() throws exception_class_name{ //method code } Lassen Sie uns nun ein Java-Programm implementieren, um das Schlüsselwort 'throw' zu demonstrieren.
In diesem Programm haben wir eine Klasse Example_throw, in der wir eine Methode testMethod haben. In der Signatur dieser testMethod deklarieren wir zwei Ausnahmen IOException und Arithmetic Exception mit dem Schlüsselwort throw. In der Hauptfunktion werden die ausgelösten Ausnahmen dann vom catch-Block behandelt.
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); } } }Ausgabe
Häufig gestellte Fragen
F # 1) Wann werden in Java Throws Throw VS Try-Catch verwendet?
Antworten: Das Schlüsselwort 'throw' wird verwendet, um die Ausnahme mit der Methodensignatur zu deklarieren. Das Schlüsselwort throw wird verwendet, um die Ausnahme explizit auszulösen. Der Try-Catch-Block wird verwendet, um die von anderen ausgelösten Ausnahmen zu behandeln.
F # 2) Können wir Würfe verwenden, versuchen und in einer einzigen Methode fangen?
Antworten: Nein. Sie können die Ausnahme nicht auslösen und auf dieselbe Weise abfangen. Die Ausnahme, die mit throw deklariert wird, muss in der aufrufenden Methode behandelt werden, die die Methode aufruft, die die Ausnahme ausgelöst hat.
F # 3) Was passiert, wenn ein Catch-Block eine Ausnahme auslöst?
Antworten: Wenn im catch-Block eine Ausnahme ausgelöst wird, stoppt das Programm die Ausführung. Wenn das Programm fortgesetzt werden muss, muss ein separater Try-Catch-Block vorhanden sein, um die im Catch-Block ausgelöste Ausnahme zu behandeln.
F # 4) Was ist Try-Catch-Endlich in Java?
Antworten: Der try-catch-finally-Block enthält die drei Blöcke, d. H. Try-Block, catch-Block und finally-Block.
Der Try-Block enthält den Code, der möglicherweise eine Ausnahme auslöst. Der Catch-Block enthält den Exception-Handler für Ausnahmen im Try-Block. Der finally-Block enthält den kritischen Code, der ausgeführt wird, unabhängig davon, ob die Ausnahme aufgetreten ist oder nicht.
F # 5) Kann Block endlich Try-Catch haben?
Antworten: Ja, wenn wir einen Bereinigungscode haben, der möglicherweise eine Ausnahme im finally-Block auslöst, können wir einen try-catch-Block haben. Es sieht jedoch hässlich aus.
Fazit
In diesem Tutorial haben wir die verschiedenen Schlüsselwörter erläutert, die bei der Ausnahmebehandlung in Java verwendet werden. Wir haben die Schlüsselwörter wie versuchen, fangen, schließlich werfen und werfen besprochen.
Der Code, der möglicherweise eine Ausnahme auslöst, ist im try-Block enthalten, und catch stellt den Handler für die Ausnahme bereit. Der finally-Block führt den darin enthaltenen Code aus, unabhängig davon, ob die Ausnahme ausgelöst wird oder nicht. Der finally-Block folgt im Allgemeinen dem try- oder try-catch-Block.
Wir verwenden das Schlüsselwort throw, um Ausnahmen mit der Methodensignatur zu deklarieren, und throw wird explizit verwendet, um Ausnahmen auszulösen. Normalerweise verwenden wir das Schlüsselwort throw, um benutzerdefinierte Ausnahmen auszulösen.
=> Lesen Sie hier den perfekten Java-Schulungsleitfaden.
Literatur-Empfehlungen
- Java-Ausnahmen und Ausnahmebehandlung mit Beispielen
- Wie gehe ich mit der ArrayIndexOutOfBoundsException in Java um?
- JAVA-Tutorial für Anfänger: Über 100 praktische Java-Video-Tutorials
- Behandlung von JDBC-Ausnahmen - Umgang mit SQL-Ausnahmen
- Tutorial zur Behandlung von C # -Ausnahmen mit Codebeispielen
- Vollständige Anleitung zur Behandlung von PL SQL-Ausnahmen mit Beispielen
- Ausnahmebehandlung in C ++
- Python Try Except - Python-Ausnahmebehandlung mit Beispielen