try catch finally
इस ट्यूटोरियल में, हम एक्सेप्शन हैंडलिंग के लिए जावा में उपयोग किए जाने वाले विभिन्न कीवर्ड्स पर चर्चा करेंगे जैसे कि आजमाएँ, कैच करें, अंत में, थ्रो और थ्रो उदाहरणों के साथ:
हमारे पिछले ट्यूटोरियल में, हमने जावा अपवाद कक्षा द्वारा समर्थित विभिन्न अपवादों के साथ-साथ जावा में अपवाद से निपटने की मूल बातें देखी हैं। हमने NullPointerException पर भी विस्तार से चर्चा की।
हम जावा में प्रदान किए गए कुछ कीवर्ड का उपयोग करके अपने कार्यक्रम में अपवादों को शामिल कर सकते हैं। ये कीवर्ड कोड के विभिन्न ब्लॉकों को परिभाषित करते हैं जो अपवादों को परिभाषित करने और संभालने की सुविधा प्रदान करते हैं।
=> एक्सक्लूसिव जावा ट्रेनिंग ट्यूटोरियल सीरीज़ के लिए यहां जाएं।
आप क्या सीखेंगे:
कोशिश करो, पकड़ो, अंत में जावा में
नीचे दिए गए कीवर्ड एक्सेप्शन हैंडलिंग के लिए जावा में उपयोग किए जाते हैं।
- प्रयत्न
- पकड़
- आखिरकार
- फेंकना
- फेंकता
निम्न तालिका इन खोजशब्दों का संक्षेप में वर्णन करती है।
| कीवर्ड | विवरण |
|---|---|
| प्रयत्न | हम उस कोड के ब्लॉक को निर्दिष्ट करते हैं जो 'कोशिश' कीवर्ड के साथ एक विशेष ब्लॉक में अपवाद को जन्म दे सकता है। |
| पकड़ | जब अपवाद को उठाया जाता है तो इसे कार्यक्रम द्वारा पकड़ा जाना चाहिए। यह एक 'कैच' कीवर्ड का उपयोग करके किया जाता है। तो एक पकड़ने वाला ब्लॉक कोशिश करता है जो एक अपवाद को उठाता है। कीवर्ड कैच को हमेशा एक कोशिश के साथ इस्तेमाल किया जाना चाहिए। |
| आखिरकार | कभी-कभी हमारे कार्यक्रम में एक महत्वपूर्ण कोड होता है, जिसे अपवाद के बावजूद निष्पादित किए जाने की आवश्यकता होती है या नहीं। यह कोड 'अंतत:' कीवर्ड के साथ शुरू होने वाले एक विशेष ब्लॉक में रखा गया है। अंत में ब्लॉक ट्राई-कैच ब्लॉक को फॉलो करता है। |
| फेंकना | कीवर्ड 'थ्रो' का उपयोग अपवाद को स्पष्ट रूप से फेंकने के लिए किया जाता है। |
| फेंकता | कीवर्ड 'थ्रो' एक अपवाद नहीं है, लेकिन इसका उपयोग अपवादों को घोषित करने के लिए किया जाता है। इस कीवर्ड का उपयोग यह इंगित करने के लिए किया जाता है कि प्रोग्राम या विधि में कोई अपवाद हो सकता है। |
इस ट्यूटोरियल में, हम प्रोग्रामिंग उदाहरणों के साथ उपरोक्त सभी खोजशब्दों पर विस्तार से चर्चा करेंगे।
जावा में ब्लॉक का प्रयास करें
जब भी हम कोई प्रोग्राम लिख रहे होते हैं तो एक कोड हो सकता है जिससे हमें संदेह हो कि हम एक अपवाद फेंक सकते हैं। उदाहरण के लिए, हमें संदेह हो सकता है कि कोड में 'शून्य से विभाजन' ऑपरेशन हो सकता है जो एक अपवाद को फेंक देगा।
यह कोड जो एक अपवाद को बढ़ा सकता है, वह कीवर्ड 'कोशिश' के साथ एक ब्लॉक में संलग्न है। तो कोशिश ब्लॉक में उन कथनों का कोड या सेट होता है जो एक अपवाद को बढ़ा सकते हैं।
कोशिश ब्लॉक का सामान्य सिंटैक्स निम्नानुसार है:
try{ //set of statements that can raise exception } इसलिए, यदि कोई प्रोग्रामर सोचता है कि कुछ बयान अपवादों को बढ़ाएंगे, तो इन बयानों को एक कोशिश ब्लॉक में संलग्न करें। ध्यान दें कि जब एक कोशिश ब्लॉक में एक विशिष्ट कथन पर अपवाद होता है, तो बाकी कोड निष्पादित नहीं होता है।
जब एक विशेष विवरण में एक कोशिश ब्लॉक में अपवाद होता है, तो नियंत्रण बाहर आता है और कार्यक्रम अचानक समाप्त हो जाता है। कार्यक्रम के इस अचानक समाप्ति को रोकने के लिए, हमें इस अपवाद को 'हैंडल' करना चाहिए। यह हैंडलिंग 'कैच' कीवर्ड का उपयोग करके किया जाता है। इसलिए एक कोशिश ब्लॉक में हमेशा इसके बाद एक पकड़ ब्लॉक होता है।
जावा में ब्लॉक पकड़ो
हम अपवादों को संभालने के लिए कैच ब्लॉक का उपयोग करते हैं। यह 'कैच' कीवर्ड के साथ ब्लॉक है। पकड़ ब्लॉक कोशिश ब्लॉक का अनुसरण करता है।
जब भी प्रयास ब्लॉक में अपवाद होता है, तो अपवाद से मेल खाने वाले कैच ब्लॉक में कोड निष्पादित होता है।
कैच ब्लॉक का सामान्य सिंटैक्स है:
catch (Exception e){ //code to handle exception e }आम तौर पर, घोषित अपवाद सभी अपवादों का मूल वर्ग होना चाहिए, अर्थात अपवाद। लेकिन अगर एक से अधिक अपवाद हैं, तो हम विशिष्ट अपवाद प्रकार या उत्पन्न अपवाद भी लिख सकते हैं।
अगला, हम कोशिश-पकड़ ब्लॉक पर चर्चा करेंगे। ध्यान दें कि प्रत्येक कोशिश ब्लॉक के लिए, हमारे पास कई कैच ब्लॉक हो सकते हैं।
कोशिश-पकड़ो जावा
ट्राइ-कैच ब्लॉक का सामान्य सिंटैक्स नीचे दिखाया गया है:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }कोशिश ब्लॉक में कोड की कई लाइनें हो सकती हैं जो कई अपवादों को उठा सकती हैं। इनमें से प्रत्येक अपवाद को एक स्वतंत्र कैच ब्लॉक द्वारा नियंत्रित किया जाता है।
अपवाद अपवाद हैंडलर, अपवाद श्रेणी का ऑब्जेक्ट ई सभी अपवादों को संभाल सकता है, लेकिन यदि हम विशिष्ट अपवादों को संभालना चाहते हैं, तो अंतिम अपवाद ब्लॉक के रूप में जेनेरिक अपवाद हैंडलर को निर्दिष्ट करना उचित है।
जावा कैच उदाहरण का प्रयास करें
अब जावा में ट्राइ-कैच ब्लॉक प्रदर्शित करें। यहां कोशिश ब्लॉक में, हम एक डिवीजन ऑपरेशन को परिभाषित करते हैं। भाजक शून्य है। इस प्रकार वह कथन जो दो संख्याओं को विभाजित करता है, अंकगणित अपवाद को जन्म देता है। हमारे पास एक पकड़ ब्लॉक है जो अंकगणित अपवाद के लिए एक हैंडलर को परिभाषित करता है।
नीचे दिया गया एक उदाहरण जावा प्रोग्राम है।
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.'); } } उत्पादन
कैसे चलाने के लिए
एकाधिक अपवादों को पकड़ना
जैसा कि पहले ही उल्लेख किया गया है, एक कोशिश ब्लॉक में एक कोड हो सकता है जो एक से अधिक अपवाद उठाता है। इस मामले में, हमें प्रत्येक अपवाद को संभालने के लिए एक से अधिक कैच ब्लॉक की आवश्यकता होगी। एक एकल प्रयास ब्लॉक का अनुसरण कई पकड़ने वाले ब्लॉक द्वारा किया जा सकता है। प्रत्येक कैच ब्लॉक स्वतंत्र अपवादों को संभालेगा।
कई कैच ब्लॉक के मामले में, हमें निम्न बिंदुओं को याद रखना होगा:
- जावा प्रोग्राम में, किसी भी समय, केवल एक अपवाद हो सकता है। इसके अलावा, किसी भी बिंदु पर, केवल एक कैच ब्लॉक निष्पादित किया जाता है।
- मल्टीपल कैच ब्लॉक्स को इस तरह से ऑर्डर किया जाना चाहिए कि सबसे विशिष्ट अपवाद के लिए कैच ब्लॉक पहले और फिर जनरल में आना चाहिए।
उदाहरण के लिए, अगर हमारे पास ArithmeticException और General Exception हैं, तो ArithmeticException को पकड़ने वाला ब्लॉक ब्लॉक पहले आएगा, उसके बाद कैच ब्लॉक हैंडलिंग Exception।
नीचे दिया गया उदाहरण कई कैच ब्लॉक प्रदर्शित करता है।
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'); } } उत्पादन
उपरोक्त कार्यक्रम में, एक ArithmeticException जिसे पहले कैच ब्लॉक में पकड़ा जाता है, उठाया जाता है। यदि यह कैच ब्लॉक निर्दिष्ट नहीं होता, तो यह अपवाद सामान्यीकृत कैच ब्लॉक में प्रचारित होता।
उपरोक्त कार्यक्रम को थोड़ा संशोधित करें ताकि कोशिश ब्लॉक दो अपवाद उठाएं। अब हम आउटपुट देखते हैं।
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'); } } उत्पादन
यदि हम इस आउटपुट को देखते हैं, तो यह दिखाता है कि ArrayIndexOutOfBoundsException को फेंका जा रहा है। ऐसा इसलिए है क्योंकि ArrayIndexOutOfBoundsException को बढ़ाने वाले कथन को पहले निष्पादित किया गया है। अपवाद फेंक दिया जाता है और नियंत्रण संबंधित कैच ब्लॉक में चला जाता है।
नेस्टेड ट्राई-कैच
एक और कोशिश ब्लॉक के अंदर एक कोशिश ब्लॉक एक नेस्टेड कोशिश ब्लॉक कहा जाता है। हमें कुछ स्थितियों में ऐसी संरचनाओं की आवश्यकता होती है, जब एक कोशिश कोड में निहित कोड का एक टुकड़ा ऐसा हो सकता है कि कुछ लाइनें कुछ अपवादों को उठाती हैं और कोड का एक और टुकड़ा पूरी तरह से अलग अपवाद को जन्म देता है।
नेस्टेड कोशिश ब्लॉक के मामले में, सबसे पहले, अंतरतम ब्लॉक को निष्पादित किया जाता है और अपवाद को नियंत्रित किया जाता है। यदि अंतरतम कोशिश ब्लॉक में एक मिलान पकड़ने वाला ब्लॉक नहीं है, तो यह अपने माता-पिता के प्रयास ब्लॉक में एक स्तर तक प्रचारित किया जाता है। इस तरह से अपवाद को ऊपर की ओर प्रचारित किया जाता है जब तक कि अपवाद हैंडलर का मिलान नहीं हो जाता।
यदि अपवाद का मिलान करने वाला कोई अपवाद हैंडलर नहीं है, तो प्रोग्राम को सिस्टम-जनित संदेश के साथ अचानक समाप्त कर दिया जाता है।
नेस्टेड प्रयास ब्लॉक का सामान्य सिंटैक्स नीचे दिया गया है:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }नेस्टेड ट्राई-कैच ब्लॉक प्रदर्शित करने के लिए एक प्रोग्राम लागू करें।
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'); } } उत्पादन
उपरोक्त कार्यक्रम में, हमारे पास दो मुख्य प्रयास ब्लॉक में संलग्न ब्लॉक हैं। दोनों इनर ट्राई ब्लॉक में एक कोड होता है जो ArithmeticException को बढ़ाता है। लेकिन हमने केवल पहले ब्लॉक के लिए एक मिलान पकड़ने वाला ब्लॉक प्रदान किया है, दूसरे प्रयास ब्लॉक के लिए नहीं।
इसलिए दूसरा ब्लॉक मुख्य प्रयास ब्लॉक के लिए इसके अपवाद का प्रचार करता है और फिर इसे संभालता है। यह आउटपुट से स्पष्ट है।
अंत में जावा में ब्लॉक
अब तक हमने ट्राइ-कैच और नेस्टेड ट्राई ब्लॉक देखा है। हम जानते हैं कि अपवाद को बढ़ाने के लिए अपेक्षित कोड को एक ब्लॉक में रखा गया है। जब अपवाद होता है, तो कोशिश ब्लॉक में शेष कोड निष्पादित नहीं किया जाता है।
यदि अपवाद को नियंत्रित नहीं किया जाता है या नियंत्रण हैंडलर को पास कर दिया जाता है, तो या तो प्रोग्राम अचानक समाप्त हो जाता है।
ऐसी स्थिति में, एक कोड को शामिल करने की आवश्यकता होती है जिसे अपवाद के बावजूद निष्पादित किया जाना है या नहीं। इसका मतलब है कि हम अपवाद होने पर भी कोड का एक टुकड़ा निष्पादित करेंगे और जब अपवाद नहीं होगा।
लेकिन जैसा कि अपवाद उठाया जाने के बाद ब्लॉक ब्लॉक से बाहर निकलता है, हम इस कोड को कोशिश ब्लॉक में नहीं डाल सकते हैं। इसी तरह, कैच ब्लॉक में एक अपवाद हैंडलर होता है, इसलिए हम इसे कैच ब्लॉक में भी नहीं डाल सकते हैं।
इस प्रकार हमें एक अलग ब्लॉक की आवश्यकता होती है जिसमें एक कोड होता है जो अपवाद के बावजूद निष्पादित होता है या नहीं। जावा एक 'अंततः' ब्लॉक प्रदान करता है जिसमें कोड का यह टुकड़ा होता है।
इसलिए जावा में अंततः ब्लॉक में महत्वपूर्ण वक्तव्य हो सकते हैं जिन्हें कार्यक्रम में निष्पादित किया जाना है। इन कथनों का निष्पादन अपवाद होने या न होने पर भी किया जाना चाहिए।
इसलिए, हम अंत में ब्लॉक में कनेक्शन, स्ट्रीम ऑब्जेक्ट, आदि या किसी भी सफाई कोड की तरह कोड डालेंगे ताकि अपवाद होने पर भी उन्हें निष्पादित किया जा सके।
जावा में अंत में ब्लॉक आमतौर पर एक कोशिश या पकड़ने ब्लॉक के बाद रखा जाता है। ध्यान दें कि अंत में ब्लॉक एक कोशिश ब्लॉक के बिना मौजूद नहीं हो सकता है। जब अंततः ब्लॉक को ट्राइ-कैच के साथ शामिल किया जाता है, तो यह ' कोशिश पकड़ने के अंत में ' खंड मैथा।
हम अपवाद हैंडलिंग कोड में अंततः ब्लॉक को छोड़ सकते हैं। इसका मतलब है कि अंत में ब्लॉक वैकल्पिक है।
यदि ट्रायल ब्लॉक कोई अपवाद नहीं बढ़ाता है, तो अंत में ब्लॉक को ट्रायल ब्लॉक के बाद निष्पादित किया जाएगा। यदि ट्रायल ब्लॉक में कोई अपवाद है तो नियंत्रण पहले कैच ब्लॉक और फिर अंत में ब्लॉक को पास करेगा।
अंत में ब्लॉक में होने वाला एक अपवाद किसी अन्य अपवाद के समान व्यवहार करता है। यहां तक कि अगर कोशिश ब्लॉक में रिटर्न स्टेटमेंट या ब्रांचिंग स्टेटमेंट जैसे ब्रेक और जारी है, तो आखिरकार ब्लॉक को अभी भी निष्पादित किया जाएगा।
इन बिंदुओं को ध्यान में रखते हुए, ले के सामान्य सिंटैक्स के साथ आगे बढ़ते हैं और अंत में ब्लॉक के उदाहरण हैं।
अंत में ब्लॉक का सामान्य सिंटैक्स निम्नानुसार है:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }हालांकि अंत में ब्लॉक को हमेशा निष्पादित किया जाता है, लेकिन कुछ ऐसी स्थितियां या मामले हैं जिनमें यह निष्पादित नहीं होता है।
ये निम्न मामले हैं:
- जब धागा मर चुका है।
- जब System.exit () विधि का उपयोग किया जाता है।
- जब अंत में ब्लॉक में एक अपवाद होता है।
चलो अंत में ब्लॉक प्रदर्शित करने के लिए कुछ कार्यक्रमों को लागू करते हैं।
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...'); } } उत्पादन
उपरोक्त कार्यक्रम एक कोशिश-कैच-अंततः ब्लॉक दिखाता है। कोशिश ब्लॉक में, एक वैध ऑपरेशन किया जाता है और इसलिए कोई अपवाद नहीं फेंका जाता है। इसलिए, नियंत्रण को कोशिश से पकड़ने के लिए नहीं बल्कि अंत में ब्लॉक करने के लिए पारित किया जाता है।
निम्न प्रोग्राम ट्राइ-कैच-अंततः ब्लॉक का एक और उदाहरण है लेकिन इस मामले में, अपवाद को ट्रायल ब्लॉक में फेंक दिया जाता है क्योंकि हम शून्य ऑपरेशन द्वारा विभाजन करते हैं। इस प्रकार अंत में ब्लॉक को निष्पादित करने की कोशिश के बाद कैच ब्लॉक निष्पादित किया जाता है।
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...'); } } उत्पादन
जावा में एक अपवाद फेंकें
जावा एक कीवर्ड 'थ्रो' प्रदान करता है जिसके उपयोग से हम स्पष्ट रूप से कोड में अपवादों को फेंक सकते हैं। उदाहरण के लिए, अगर हम अंकगणित संचालन की जाँच कर रहे हैं और संचालन की जाँच के बाद कुछ अपवादों को उठाना चाहते हैं तो हम। थ्रो ’कीवर्ड का उपयोग कर सकते हैं।
थ्रो कीवर्ड का उपयोग करके, हम चेक किए गए या अनियंत्रित अपवादों को फेंक सकते हैं। थ्रो कीवर्ड का उपयोग कस्टम अपवादों को फेंकने के लिए भी किया जाता है।
थ्रो कीवर्ड का सामान्य सिंटैक्स है:
throw exception; or throw new exception_class('error message'); नीचे दिया गया एक उदाहरण है, फेंक कीवर्ड प्रदर्शित करने के लिए एक कार्यक्रम।
ओपन सोर्स रिलेशनल डेटाबेस मैनेजमेंट सिस्टम
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...'); } } उत्पादन
उपरोक्त कार्यक्रम में, हम उम्र को मान्य करने के लिए एक विधि का उपयोग करते हैं। अगर उम्र है<18, then an exception is thrown to indicate the age is not valid.
खण्ड फेंकता है
हमने अपवादों को घोषित करने के लिए प्रयास ब्लॉक देखा है। इसमें वह कोड है जो अपवादों को उठा सकता है। अपवाद घोषित करने का एक और तरीका है और वह 'थ्रो' कीवर्ड का उपयोग करना है।
'थ्रो' कीवर्ड का उपयोग करते हुए अपवाद की घोषणा प्रोग्रामर को बताती है कि 'थ्रो' कीवर्ड के बाद एक अपवाद निर्दिष्ट हो सकता है और प्रोग्रामर को प्रोग्राम के सामान्य प्रवाह को बनाए रखने के लिए इस अपवाद के लिए संबंधित हैंडलर कोड प्रदान करना चाहिए।
हालाँकि, यह सवाल उठता है कि जब अपवाद घोषित करने और संभालने के लिए हमारे पास अधिक विश्वसनीय ट्राइ-कैच ब्लॉक है तो हमें 'थ्रो' कीवर्ड की आवश्यकता क्यों है?
एक कारण अपवादों की संख्या है जो संभवतः बढ़ सकती है, कैच ब्लॉक की संख्या जो अपवादों को भी संभालती है क्योंकि एक कैच ब्लॉक केवल एक अपवाद को संभाल सकता है।
इसी प्रकार, यदि किसी प्रोग्राम में कई विधियाँ हैं और प्रत्येक विधि में कई अपवाद हैं, तो कोड अनावश्यक रूप से लंबा और असहनीय हो जाएगा।
इस प्रकार विधि हस्ताक्षर में थ्रो कीवर्ड के साथ एक अपवाद की घोषणा करना और फिर कोशिश-कैच का उपयोग करके विधि कॉल को संभालना एक व्यवहार्य समाधान प्रतीत होता है।
थ्रो कीवर्ड का उपयोग करके अपवाद घोषित करने का एक और फायदा यह है कि हम अपवादों को संभालने के लिए मजबूर हो जाते हैं। यदि हम एक घोषित अपवाद के लिए हैंडलर प्रदान नहीं करते हैं, तो प्रोग्राम एक त्रुटि उठाएगा।
थ्रो कीवर्ड का सामान्य सिंटैक्स निम्नानुसार है:
return_type method_name() throws exception_class_name{ //method code } आइए अब “थ्रो” कीवर्ड प्रदर्शित करने के लिए जावा प्रोग्राम लागू करते हैं।
इस कार्यक्रम में, हमारे पास एक उदाहरण example_throw है जिसमें हमारे पास एक विधि टेस्टमेथोड है। इस टेस्टमेथोड के हस्ताक्षर में, हम दो अपवाद IOException और Arithmetic Exception को थ्रो कीवर्ड का उपयोग करते हुए घोषित करते हैं। फिर मुख्य फ़ंक्शन में, फेंके गए अपवादों को कैच ब्लॉक द्वारा नियंत्रित किया जाता है।
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); } } }उत्पादन
बार बार पूछे जाने वाले प्रश्न
क्यू # 1) जावा में वीएस ट्राइ-थ्रो फेंकने का उपयोग कब करें?
उत्तर: 'थ्रो' कीवर्ड का उपयोग विधि हस्ताक्षर के साथ अपवाद घोषित करने के लिए किया जाता है। थ्रो कीवर्ड का उपयोग स्पष्ट रूप से अपवाद को फेंकने के लिए किया जाता है। ट्राइ-कैच ब्लॉक का उपयोग दूसरों द्वारा फेंके गए अपवादों को संभालने के लिए किया जाता है।
Q # 2) क्या हम एकल विधि में थ्रो का उपयोग कर सकते हैं, कोशिश कर सकते हैं और पकड़ सकते हैं?
उत्तर: नहीं। आप अपवाद को फेंक नहीं सकते हैं और इसे उसी विधि में भी पकड़ सकते हैं। थ्रो का उपयोग करके जो अपवाद घोषित किया गया है, उसे कॉलिंग विधि में संभाला जाना चाहिए जो उस पद्धति को कॉल करता है जिसने अपवाद को फेंक दिया है।
Q # 3) क्या होता है जब एक कैच ब्लॉक एक अपवाद फेंकता है?
उत्तर: जब एक अपवाद को पकड़ ब्लॉक में फेंक दिया जाता है, तो प्रोग्राम निष्पादन को रोक देगा। यदि प्रोग्राम को जारी रखना है, तो कैच ब्लॉक में उठाए गए अपवाद को संभालने के लिए अलग-अलग ट्राइ-कैच ब्लॉक होना चाहिए।
Q # 4) जावा में आखिर कोशिश-कैच क्या है?
उत्तर: ट्राइ-कैच-आखिर ब्लॉक में तीन ब्लॉक होते हैं यानी ब्लॉक, कैच ब्लॉक, और अंत में ब्लॉक की कोशिश करें।
प्रयास करें ब्लॉक में वह कोड है जो एक अपवाद को फेंक सकता है। कैच ब्लॉक में ट्राई ब्लॉक में अपवादों के लिए अपवाद हैंडलर होता है। अंत में ब्लॉक में महत्वपूर्ण कोड होता है जो अपवाद के बिना निष्पादित होगा या नहीं।
Q # 5) आखिरकार कोशिश कर सकते हैं?
उत्तर: हां, यदि हमारे पास एक सफाई कोड है जो अंत में ब्लॉक में एक अपवाद को फेंक सकता है, तो हमारे पास एक ट्राइ-कैच ब्लॉक हो सकता है। हालांकि, यह बदसूरत दिखता है।
निष्कर्ष
इस ट्यूटोरियल में, हमने जावा में अपवाद हैंडलिंग में उपयोग किए गए विभिन्न कीवर्ड्स पर चर्चा की। हमने कोशिश, पकड़, अंत में, फेंक और फेंको जैसे कीवर्ड पर चर्चा की है।
कोड जो संभवतः एक अपवाद को फेंक देगा, कोशिश ब्लॉक में संलग्न है और अपवाद के लिए हैंडलर प्रदान करता है। अंत में ब्लॉक इसमें दिए गए कोड को निष्पादित करता है, भले ही अपवाद फेंक दिया गया हो या नहीं। अंत में ब्लॉक आम तौर पर कोशिश या पकड़ने वाले ब्लॉक का अनुसरण करता है।
हम थ्रेड कीवर्ड का उपयोग विधि हस्ताक्षर के साथ अपवादों को घोषित करने के लिए करते हैं और अपवादों को फेंकने के लिए फेंक स्पष्ट रूप से उपयोग किया जाता है। हम आम तौर पर कस्टम अपवादों को फेंकने के लिए थ्रो कीवर्ड का उपयोग करते हैं।
=> यहाँ बिल्कुल सही जावा प्रशिक्षण गाइड देखें।
अनुशंसित पाठ
- उदाहरणों के साथ जावा अपवाद और अपवाद हैंडलिंग
- जावा में ArrayIndexOutOfBoundsException कैसे संभालें?
- जावा ट्यूटोरियल फॉर बिगिनर्स: 100+ हैंड्स-ऑन जावा वीडियो ट्यूटोरियल
- JDBC अपवाद हैंडलिंग - SQL अपवाद को कैसे हैंडल करें
- कोड उदाहरणों के साथ C # अपवाद हैंडलिंग ट्यूटोरियल
- उदाहरणों के साथ PL SQL एक्सेप्शन हैंडलिंग के लिए पूरी गाइड
- C ++ में अपवाद हैंडलिंग
- अजगर को छोड़कर प्रयास करें - उदाहरण के साथ पायथन हैंडलिंग अपवाद