🕵🏻 🧑🏾‍🤝‍🧑🏼 👨‍❤️‍💋‍👨 जावा में अपवाद, भाग I (प्रयास-अंत में पकड़) 👩‍🏫 ⤵️ 💾

यह इस तरह के जावा भाषा तंत्र के लिए अपवाद के रूप में समर्पित (दूसरे (जाँच / अनियंत्रित) यहाँ ) लेख का पहला भाग है। इसमें एक परिचयात्मक चरित्र है और इसे शुरुआती डेवलपर्स या उन लोगों के लिए डिज़ाइन किया गया है जो अभी भाषा सीखना शुरू कर रहे हैं।

मैं ऑनलाइन शिक्षा प्लेटफॉर्म udemy.com (कौरसेरा / एडएक्स के समान) पर जावा डेवलपर्स कोर्स के लिए स्काला भी सिखाता हूं।

1. कीवर्ड: कोशिश, पकड़, अंत में, फेंक, फेंको

2. क्यों System.err का उपयोग करें, System.out का नहीं

3. संकलक को एक वापसी परिणाम की आवश्यकता होती है (या मौन की आवश्यकता होती है)

4. गैर-नियंत्रण नियंत्रण हस्तांतरण

5. कोशिश + पकड़ (पकड़ - बहुरूपी)

6. try + catch + catch + ...

7.ट्री + आखिर

8.ट्री + कैच + आखिर

9. नेस्टेड कोशिश + पकड़ + अंत में

1. कीवर्ड: कोशिश, पकड़, अंत में, फेंक, फेंको

जावा एक्सक्लूजन मेकेनिज्म सपोर्टेड फाइव कीवर्ड

कोशिश
पकड़
अंत में
फेंक
फेंकता

"जादू" (यानी, कुछ व्यवहार किसी भी तरह से स्रोत कोड में परिलक्षित नहीं होता है और इसलिए उपयोगकर्ता द्वारा दोहराया नहीं जाता है) अपवाद # 1 यह है कि पकड़, फेंक, फेंकता का उपयोग विशेष रूप से java.lang.Throwable या इसके वंश के साथ किया जा सकता है।

फेंकता है:

के लिए अच्छा है

public class App { public static void main(String[] args) throws Throwable {} }

अच्छा नहीं है

 public class App { public static void main(String[] args) throws String {} } >> COMPILATION ERROR: Incompatible types: required 'java.lang.Throwable', found: 'java.lang.String'

पकड़ने:

के लिए अच्छा है

 public class App { public static void main(String[] args) { try { } catch (Throwable t) {} } }

अच्छा नहीं है

 public class App { public static void main(String[] args) { try { } catch (String s) {} } } >> COMPILATION ERROR: Incompatible types: required 'java.lang.Throwable', found: 'java.lang.String'

फेंक:

के लिए अच्छा है

 public class App { public static void main(String[] args) { // Error -  Throwable throw new Error(); } }

अच्छा नहीं है

 public class App { public static void main(String[] args) { throw new String("Hello!"); } } >> COMPILATION ERROR: Incompatible types: required 'java.lang.Throwable', found: 'java.lang.String'

इसके अलावा, थ्रो को एक गैर-अशक्त तर्क की आवश्यकता होती है, अन्यथा रन समय पर एक NullPointerException

 public class App { public static void main(String[] args) { throw null; } } >> RUNTIME ERROR: Exception in thread "main" java.lang.NullPointerException

फेंकना और नया दो स्वतंत्र संचालन हैं। निम्नलिखित कोड में, हम स्वतंत्र रूप से एक अपवाद वस्तु बनाते हैं और इसे "फेंक" देते हैं

 public class App { public static void main(String[] args) { Error ref = new Error(); //   throw ref; // ""  } } >> RUNTIME ERROR: Exception in thread "main" java.lang.Error

हालाँकि, इसका विश्लेषण करने की कोशिश करें।

 public class App { public static void main(String[] args) { f(null); } public static void f(NullPointerException e) { try { throw e; } catch (NullPointerException npe) { f(npe); } } } >> RUNTIME ERROR: Exception in thread "main" java.lang.StackOverflowError

2. क्यों System.err का उपयोग करें, System.out का नहीं

System.out एक बफर आउटपुट स्ट्रीम है, लेकिन System.err नहीं है। इस प्रकार, निष्कर्ष इस प्रकार हो सकता है

 public class App { public static void main(String[] args) { System.out.println("sout"); throw new Error(); } } >> RUNTIME ERROR: Exception in thread "main" java.lang.Error >> sout

तो यहाँ यह है (कंसोल पर आउटपुट करते समय ओवरटेक किया गया)

 public class App { public static void main(String[] args) { System.out.println("sout"); throw new Error(); } } >> sout >> RUNTIME ERROR: Exception in thread "main" java.lang.Error

चलो इसे ड्रा करें

    +----------------+ +->| msg2 msg1 msg0 | --> out / +----------------+ \ / +-> +--------+   | | \ +-> +--------+ \ / +------------------------> err  ,

जब आप System.err को लिखते हैं, तो आपका संदेश तुरंत कंसोल पर प्रदर्शित होता है, लेकिन जब आप System.out को लिखते हैं, तो यह कुछ समय के लिए बफ़र किया जा सकता है। स्टैक्ट्रेस को एक अनहैंडल्ड अपवाद System.err के माध्यम से फेंक दिया जाता है, जो उन्हें "नियमित" संदेशों से आगे निकलने की अनुमति देता है।

3. संकलक को एक वापसी परिणाम की आवश्यकता होती है (या मौन की आवश्यकता होती है)

यदि विधि घोषणा कहती है कि यह शून्य नहीं है, तो संकलक सतर्कता से देखता है कि हम आवश्यक प्रकार का एक उदाहरण या उस प्रकार का उदाहरण लौटाते हैं जिसे आवश्यक रूप से डाला जा सकता है

 public class App { public double sqr(double arg) { //  double return arg * arg; // double * double -  double } }

 public class App { public double sqr(double arg) { //  double int k = 1; //  int return k; //    int  double } }

 //   ,   -    public class App { public double sqr(double arg) { //  double int k = 1; //  int return (double) k; //   int  double } }

यह काम नहीं करेगा (दूसरा प्रकार)

 public class App { public static double sqr(double arg) { return "hello!"; } } >> COMPILATION ERROR: Incompatible types. Required: double. Found: java.lang.String

यह काम नहीं करता है - कोई वापसी नहीं

 public class App { public static double sqr(double arg) { } } >> COMPILATION ERROR: Missing return statement

और यह उस तरह से काम नहीं करेगा (कंपाइलर यह सुनिश्चित नहीं कर सकता कि वापसी होगी)

 public class App { public static double sqr(double arg) { if (System.currentTimeMillis() % 2 == 0) { return arg * arg; //  currentTimeMillis() -  ,    } //   ,   ? } } >> COMPILATION ERROR: Missing return statement

कंपाइलर मॉनिटर करता है कि हम कुछ वापस करते हैं, अन्यथा यह स्पष्ट नहीं है कि इस कार्यक्रम को क्या प्रिंट करना चाहिए

 public class App { public static void main(String[] args) { double d = sqr(10.0); // ,    d? System.out.println(d); } public static double sqr(double arg) { // nothing } } >> COMPILATION ERROR: Missing return statement

मज़े के कारण, आप कुछ भी नहीं लौटा सकते हैं, लेकिन "विधि लटकाएँ"

 public class App { public static double sqr(double arg) { while (true); // ,  ! } }

यहाँ d में, कुछ भी कभी नहीं सौंपा जाएगा, क्योंकि sqr पद्धति लटकी हुई है

 public class App { public static void main(String[] args) { double d = sqr(10.0); // sqr -  "",  System.out.println(d); // d -     ! } public static double sqr(double arg) { while (true); //      "" } }

संकलक "प्लग" को छोड़ देगा (फिर भी एक वर्ग या लटका लें)

 public class App { public static double sqr(double arg) { if (System.currentTimeMillis() % 2 == 0) { return arg * arg; //  ,   double } else { while (true); //   ""  } } }

लेकिन अपवाद तंत्र कुछ भी हासिल करने की अनुमति नहीं देता है!

 public class App { public static double sqr(double arg) { throw new RuntimeException(); } }

इसलिए, हमारे पास कंपाइलर के लिए तीन विकल्प हैं

 public class App { public static double sqr(double arg) {//       double long time = System.currentTimeMillis(); if (time % 2 == 0) { return arg * arg; // ,   double } else if (time % 2 == 1) { { while (true); // ,   "" } else { throw new RuntimeException(); //    } } }

लेकिन डबल क्या RuntimeException फेंकने समारोह वापस आ जाएगी?

और नहीं!

 public class App { public static void main(String[] args) { // sqr - "" (  "" ), double d = sqr(10.0); //   main()      // d -     ! System.out.println(d); //      ! } public static double sqr(double arg) { throw new RuntimeException(); // ""  } } >> RUNTIME ERROR: Exception in thread "main" java.lang.RuntimeException

संक्षेप में: फेंक दिया गया अपवाद वैकल्पिक रिटर्न प्रकार है। यदि आपकी विधि ने घोषित किया है कि यह दोगुना है, लेकिन आपके पास दोगुना नहीं है, तो आप एक अपवाद फेंक सकते हैं। यदि आपकी विधि ने घोषित किया है कि यह कुछ भी नहीं देता है (शून्य), लेकिन आपके पास अभी भी कुछ कहने के लिए है, तो आप एक अपवाद फेंक सकते हैं।

आइए कुछ व्यावहारिक उदाहरण देखें।

कार्य: एक फ़ंक्शन को लागू करें जो एक आयत के क्षेत्र की गणना करता है

 public static int area(int width, int height) {...}

यह महत्वपूर्ण है कि कार्य वास्तव में इस तरह से लगता है, विषय क्षेत्र के संदर्भ में - "आयत के क्षेत्र की गणना करें", और निर्णय के संदर्भ में "दो संख्याओं को गुणा करें":

 public static int area(int width, int height) { return width * height; //    }

प्रश्न: क्या होगा अगर हम पाते हैं कि कम से कम एक तर्क एक नकारात्मक संख्या है?

यदि हम बस गुणा करते हैं, तो हमने त्रुटिपूर्ण डेटा को आगे छोड़ दिया है। इससे भी बदतर, शायद हमने "स्थिति को सही किया" - उन्होंने कहा कि दो नकारात्मक पक्षों के साथ आयत का क्षेत्र -10 और -20 = 200 है।

हम कुछ भी नहीं लौटा सकते

 public static int area(int width, int height) { if (width < 0 || height < 0) { //    ,  } else { return width * height; } } >> COMPILATION ERROR: Missing return statement

आप निश्चित रूप से, कंसोल को अनसब्सक्राइब कर सकते हैं, लेकिन इसे कौन पढ़ेगा और कैसे निर्धारित किया जाएगा कि ब्रेकडाउन कहां था। इसके अलावा, गणना गलत डेटा के साथ जारी रहेगी।

 public static int area(int width, int height) { if (width < 0 || height < 0) { System.out.println("Bad ..."); } return width * height; }

आप एक विशेष मान दर्शा सकते हैं कि कुछ गलत है (त्रुटि कोड), लेकिन कौन गारंटी देता है कि वे इसे पढ़ेंगे, और इसका उपयोग नहीं करेंगे?

 public static int area(int width, int height) { if (width < 0 || height < 0) { return -1; //  ""   } return width * height; }

बेशक, हम वर्चुअल मशीन को पूरी तरह से रोक सकते हैं

 public static int area(int width, int height) { if (width < 0 || height < 0) { System.exit(0); } return width * height; }

लेकिन "सही तरीका" यह है: यदि आप संभव गलत व्यवहार पाते हैं, तो

1. गणना रोकें, एक ब्रेकडाउन संदेश उत्पन्न करें जिसे अनदेखा करना मुश्किल है, उपयोगकर्ता को कारण के बारे में जानकारी प्रदान करें, उपयोगकर्ता को सब कुछ ठीक करने का अवसर दें (कपड़े धोने का भार वापस करें और फिर से प्रारंभ बटन दबाएं)

 public static int area(int width, int height) { if (width < 0 || height < 0) { throw new IllegalArgumentException("Negative sizes: w = " + width + ", h = " + height); } return width * height; }

4. गैर-नियंत्रण नियंत्रण हस्तांतरण

असाधारण स्थितियों का तंत्र (अपवाद) प्रबंधन के गैर-स्थानीय स्थानांतरण का तंत्र है।

इसका क्या मतलब है?

कार्यक्रम, इसके निष्पादन के दौरान (अधिक सटीक रूप से, एक अलग थ्रेड के भीतर निर्देशों का निष्पादन), फ्रेम के एक स्टैक ("स्टैक") से संचालित होता है। नियंत्रण का हस्तांतरण या तो एक फ्रेम के भीतर किया जाता है

 public class App { public static void main(String[] args) { // :   int x = 42; //   int y = x * x; //   x = x * y; //   ... } }

 public class App { public static void main(String[] args) { // :   if (args.length > 2) {   //     ... } else { //   ... } //   ... } }

 public class App { public static void main(String[] args) { // :   do..while int x = 1; do { ... } while (x++ < 10); ... } }

और अन्य ऑपरेटरों।

या नियरबोर्डिंग फ्रेम के बीच फ्रेम के "स्टैक" में कंट्रोल ट्रांसफर होता है

विधि कॉल: एक नया फ्रेम बनाएं, इसे स्टैक के शीर्ष पर रखें और इसमें जाएं
विधि से बाहर निकलें: पिछले फ्रेम पर लौटें (वापसी के माध्यम से या विधि में निर्देश बस समाप्त हो गए)

वापसी - एक फ्रेम से बाहर निकलें (फ्रेम # 4 (एच) विधि से))

 public class App { public static void main(String[] args) { System.err.println("#1.in"); f(); //  ,   ,     System.err.println("#1.out"); //  } //    ,   public static void f() { System.err.println(". #2.in"); g(); //  ,   ,     System.err.println(". #2.out"); // } //    ,   public static void g() { System.err.println(". . #3.in"); h(); //  ,   ,     System.err.println(". . #3.out"); //  } //    ,   public static void h() { System.err.println(". . . #4.in"); if (true) { System.err.println(". . . #4.RETURN"); return; //      'return' } System.err.println(". . . #4.out"); //  } } >> #1.in >> . #2.in >> . . #3.in >> . . . #4.in >> . . . #4.RETURN >> . . #3.out >> . #2.out >> #1.out

फेंक - सभी फ्रेम से बाहर निकलें

 public class App { public static void main(String[] args) { System.err.println("#1.in"); f(); //  ,   ,     System.err.println("#1.out"); // ! } public static void f() { System.err.println(". #2.in"); g(); //  ,   ,     System.err.println(". #2.out"); // ! } public static void g() { System.err.println(". . #3.in"); h(); //  ,   ,     System.err.println(". . #3.out"); // ! } public static void h() { System.err.println(". . . #4.in"); if (true) { System.err.println(". . . #4.THROW"); throw new Error(); //      (" ")  'throw' } System.err.println(". . . #4.out"); // ! } } >> #1.in >> . #2.in >> . . #3.in >> . . . #4.in >> . . . #4.THROW >> RUNTIME ERROR: Exception in thread "main" java.lang.Error

पकड़ने के साथ, हम उड़ान अपवाद को रोक सकते हैं (कारण हम स्वचालित रूप से फ्रेम छोड़ देते हैं)।

हम 3 फ़्रेम के माध्यम से रुकते हैं, फ्रेम # 4 (विधि h ()) + के माध्यम से उड़ते हैं # 3 (विधि g ()) + फ्रेम # 2 (विधि f ())

 public class App { public static void main(String[] args) { System.err.println("#1.in"); try { f(); //  ,   ,     } catch (Error e) { // "" ""  System.err.println("#1.CATCH"); //   } System.err.println("#1.out"); //   } public static void f() { System.err.println(". #2.in"); g(); //  ,   ,     System.err.println(". #2.out"); // ! } public static void g() { System.err.println(". . #3.in"); h(); //  ,   ,     System.err.println(". . #3.out"); // ! } public static void h() { System.err.println(". . . #4.in"); if (true) { System.err.println(". . . #4.THROW"); throw new Error(); //      (" ")  'throw' } System.err.println(". . . #4.out"); // ! } } >> #1.in >> . #2.in >> . . #3.in >> . . . #4.in >> . . . #4.THROW >> #1.CATCH >> #1.out

कृपया ध्यान दें कि मानक स्क्रिप्ट मुख्य () विधि (फ्रेम # 1) में बहाल किया गया था

हम 2 फ़्रेमों के माध्यम से रुकते हैं, फ़्रेम # 4 (h () विधि) के माध्यम से उड़ते हैं + फ्रेम 3 (g () विधि) के माध्यम से उड़ते हैं

 public class App { public static void main(String[] args) { System.err.println("#1.in"); f(); //  ,   ,     System.err.println("#1.out"); //    } public static void f() { System.err.println(". #2.in"); try { g(); //  ,   ,     } catch (Error e) { // "" ""  System.err.println(". #2.CATCH"); //   } System.err.println(". #2.out"); //   } public static void g() { System.err.println(". . #3.in"); h(); //  ,   ,     System.err.println(". . #3.out"); // ! } public static void h() { System.err.println(". . . #4.in"); if (true) { System.err.println(". . . #4.THROW"); throw new Error(); //      (" ")  'throw' } System.err.println(". . . #4.out"); // ! } } >> #1.in >> . #2.in >> . . #3.in >> . . . #4.in >> . . . #4.THROW >> . #2.CATCH >> . #2.out >> #1.out

हम 1 फ्रेम के बाद रुकते हैं (वास्तव में, रिटर्न का एनालॉग, बस फ्रेम को "एक अलग तरीके से" छोड़ दिया जाता है)

 public class App { public static void main(String[] args) { System.err.println("#1.in"); f(); //  ,   ,     System.err.println("#1.out"); //    } public static void f() { System.err.println(". #2.in"); g(); //  ,   ,     System.err.println(". #2.out"); //    } public static void g() { System.err.println(". . #3.in"); try { h(); //  ,   ,     } catch (Error e) { // "" ""  System.err.println(". . #3.CATCH"); //   } System.err.println(". . #3.out"); //   } public static void h() { System.err.println(". . . #4.in"); if (true) { System.err.println(". . . #4.THROW"); throw new Error(); //      (" ")  'throw' } System.err.println(". . . #4.out"); // ! } } >> #1.in >> . #2.in >> . . #3.in >> . . . #4.in >> . . . #4.THROW >> . . #3.CATCH >> . . #3.out >> . #2.out >> #1.out

तो, चलो एक तस्वीर के लिए सब कुछ कम करें

 // --- RETURN--- // --- THROW--- //   1-  //    ( 4)  #1.in #1.in . #2.in . #2.in . . #3.in . . #3.in . . . #4.in . . . #4.in . . . #4.RETURN . . . #4.THROW . . #3.out RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error . #2.out #1.out // --- THROW+CATCH--- //   3-  //   2-  //   1-  #1.in #1.in #1.in . #2.in . #2.in . #2.in . . #3.in . . #3.in . . #3.in . . . #4.in . . . #4.in . . . #4.in . . . #4.THROW . . . #4.THROW . . . #4.THROW #1.CATCH . #2.CATCH . . #3.CATCH #1.out . #2.out . . #3.out #1.out . #2.out #1.out

5. कोशिश + पकड़ (पकड़ - बहुरूपी)

अपवाद पदानुक्रम को याद करें

  Object | Throwable / \ Error Exception | RuntimeException

यह तथ्य कि अपवाद वस्तुएं हैं, हमारे लिए दो तरह से महत्वपूर्ण हैं

1. वे जड़ java.lang.Throwable (java.lang.Object java.lang.Throwable के पूर्वज है, के साथ एक पदानुक्रम बनाते हैं, लेकिन ऑब्जेक्ट अब एक अपवाद नहीं है)

2. उनके पास फ़ील्ड और विधियाँ हो सकती हैं (हम इस लेख में इसका उपयोग नहीं करेंगे)

पहले बिंदु के अनुसार: पकड़ - बहुरूपी निर्माण, अर्थात्। माता-पिता द्वारा किसी भी प्रकार के उड़ान उदाहरणों को पकड़ना माता-पिता (यानी, माता-पिता के सीधे उदाहरण या माता-पिता का कोई वंशज)

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new RuntimeException();} System.err.print(" 1"); } catch (Exception e) { // catch  Exception  RuntimeException System.err.print(" 2"); } System.err.println(" 3"); } } >> 0 2 3

यहां तक कि: कैच ब्लॉक में, हमारे पास प्रकार के अपवाद का एक प्रकार होगा, जो टाइप RuntimeException के ऑब्जेक्ट पर होता है

 public class App { public static void main(String[] args) { try { throw new RuntimeException(); } catch (Exception e) { if (e instanceof RuntimeException) { RuntimeException re = (RuntimeException) e; System.err.print(" RuntimeException   !!!"); } else { System.err.print("    RuntimeException???"); } } } } >>  RuntimeException   !!!

बच्चे द्वारा पकड़ना पूर्वज को पकड़ नहीं सकता है

 public class App { public static void main(String[] args) throws Exception { //   'throws' try { System.err.print(" 0"); if (true) {throw new Exception();} System.err.print(" 1"); } catch (RuntimeException e) { System.err.print(" 2"); } System.err.print(" 3"); } } >> 0 >> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Exception

एक "भाई" पर पकड़ दूसरे "भाई" को नहीं पकड़ सकती (त्रुटि और अपवाद माता-पिता के बच्चे के रिश्ते में नहीं हैं, वे थ्रोबेबल से समानांतर विरासत शाखाओं से हैं)

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new Error();} System.err.print(" 1"); } catch (Exception e) { System.err.print(" 2"); } System.err.print(" 3"); } } >> 0 >> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error

पिछले उदाहरणों के अनुसार - मुझे आशा है कि आपने देखा है कि यदि अपवाद पकड़ा गया है, तो JVM उन कथनों को निष्पादित करता है जो अंतिम प्रयास + पकड़ने वाली कोष्ठक के बाद आते हैं।

लेकिन अगर इंटरसेप्ट नहीं हुआ तो हम

1. पकड़ ब्लॉक में मत जाओ

2. उड़ान अपवाद के साथ विधि के फ्रेम को छोड़ दें

लेकिन क्या होगा अगर हम पकड़ में जाते हैं और फिर एक अपवाद को पकड़ लेते हैं?

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new RuntimeException();} System.err.print(" 1"); } catch (RuntimeException e) { //  RuntimeException System.err.print(" 2"); if (true) {throw new Error();} //   Error } System.err.println(" 3"); //  -   Error } } >> 0 2 >> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error

इस मामले में, विधि का निष्पादन भी बाधित है ("3" प्रिंट न करें)। नए अपवाद का ट्राय-कैच से कोई लेना-देना नहीं है

हम उस वस्तु को फेंक सकते हैं जो हमारे पास "हाथ पर" है

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new RuntimeException();} System.err.print(" 1"); } catch (RuntimeException e) { //  RuntimeException System.err.print(" 2"); if (true) {throw e;} //       } System.err.println(" 3"); //  -   RuntimeException } } >> 0 2 >> RUNTIME EXCEPTION: Exception in thread "main" java.lang.RuntimeException

और हम अन्य कैच सेक्शन में नहीं आएंगे, यदि कोई हो

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new RuntimeException();} System.err.print(" 1"); } catch (RuntimeException e) { //  RuntimeException System.err.print(" 2"); if (true) {throw new Error();} //    Error } catch (Error e) { //   cath  Error "",       System.err.print(" 3"); } System.err.println(" 4"); } } >> 0 2 >> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error

कृपया ध्यान दें कि हमने "3" प्रिंट नहीं किया है, हालांकि हमारे पास एरर फ्लाइंग है और "नीचे" एरर पर पकड़ है। लेकिन महत्वपूर्ण बिंदु यह है कि कैच को विशेष रूप से ट्राइ सेक्शन के साथ नहीं बल्कि अन्य कैच सेक्शन के साथ करना है।

जैसा कि हम नीचे दिखाते हैं - आप नेस्टेड संरचनाओं का निर्माण कर सकते हैं, लेकिन यहां एक उदाहरण है कि इस स्थिति को "ठीक करता है"

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new RuntimeException();} System.err.print(" 1"); } catch (RuntimeException e) { //  RuntimeException System.err.print(" 2.1"); try { System.err.print(" 2.2"); if (true) {throw new Error();} //    Error System.err.print(" 2.3"); } catch (Throwable t) { //  Error System.err.print(" 2.4"); } System.err.print(" 2.5"); } catch (Error e) { //   cath  Error "",       System.err.print(" 3"); } System.err.println(" 4"); } } >> 0 2.1 2.2 2.4 2.5 4

6. try + catch + catch + ...

जैसा कि आपने देखा, हम एक कोशिश के बाद कई कैच की व्यवस्था कर सकते हैं।

लेकिन ऐसा नियम है - आप पूर्वज के बाद एक वंशज नहीं डाल सकते हैं! (अपवाद के बाद RuntimeException)

 public class App { public static void main(String[] args) { try { } catch (Exception e) { } catch (RuntimeException e) { } } } >> COMPILATION ERROR: Exception 'java.lang.RuntimeException' has alredy been caught

भाई को भाई के बाद रखना संभव है (त्रुटि के बाद RuntimeException)

 public class App { public static void main(String[] args) { try { } catch (Error e) { } catch (RuntimeException e) { } } }

"सही" कैच चुनने से क्या होता है? हां, यह बहुत सरल है - जेवीएम ऊपर से नीचे तक जाता है जब तक कि वह ऐसा पकड़ नहीं पाता है कि आपका अपवाद उसमें इंगित किया गया है या उसके पूर्वज वहां जाते हैं। नीचे - नहीं जाता है।

 public class App { public static void main(String[] args) { try { throw new Exception(); } catch (RuntimeException e) { System.err.println("catch RuntimeException"); } catch (Exception e) { System.err.println("catch Exception"); } catch (Throwable e) { System.err.println("catch Throwable"); } System.err.println("next statement"); } } >> catch Exception >> next statement

कैच का विकल्प रनटाइम में बनाया जाता है (और संकलन-समय में नहीं), इसलिए यह उस प्रकार का लिंक (थ्रोसेबल) नहीं है जिसे ध्यान में रखा जाता है, लेकिन लिंक्ड (अपवाद) का प्रकार

 public class App { public static void main(String[] args) { try { Throwable t = new Exception(); //   Throwable     Exception throw t; } catch (RuntimeException e) { System.err.println("catch RuntimeException"); } catch (Exception e) { System.err.println("catch Exception"); } catch (Throwable e) { System.err.println("catch Throwable"); } System.err.println("next statement"); } } >> catch Exception >> next statement

7.ट्री + आखिर

अगर ब्लॉक सफल होता है तो अंत में सेक्शन को नियंत्रण मिल जाता है

 public class App { public static void main(String[] args) { try { System.err.println("try"); } finally { System.err.println("finally"); } } } >> try >> finally

अंतत: खंड को नियंत्रण मिल जाता है, भले ही प्रयास खंड एक अपवाद के साथ समाप्त हो जाए।

 public class App { public static void main(String[] args) { try { throw new RuntimeException(); } finally { System.err.println("finally"); } } } >> finally >> Exception in thread "main" java.lang.RuntimeException

अंत में सेक्शन कंट्रोल हो जाता है, भले ही ट्राई ब्लॉक एक मेथड एग्जिट निर्देश के साथ समाप्त हो जाए

 public class App { public static void main(String[] args) { try { return; } finally { System.err.println("finally"); } } } >> finally

अंत में खंड को केवल तभी नहीं कहा जाता है जब हम JVM को "नस्टेड" करते हैं

 public class App { public static void main(String[] args) { try { System.exit(42); } finally { System.err.println("finally"); } } } >> Process finished with exit code 42

System.exit (42) और Runtime.getRuntime ()। Exit (42) समानार्थक शब्द हैं

 public class App { public static void main(String[] args) { try { Runtime.getRuntime().exit(42); } finally { System.err.println("finally"); } } } >> Process finished with exit code 42

और Runtime.getRuntime () के साथ। हॉल्ट (42) - भी अंत में जाने का समय नहीं है

 public class App { public static void main(String[] args) { try { Runtime.getRuntime().halt(42); } finally { System.err.println("finally"); } } } >> Process finished with exit code 42

निकास () बनाम पड़ाव ()

javadoc: java.lang.Runtime # halt (int स्थिति)

... बाहर निकलने की विधि के विपरीत, इस विधि से शटडाउन हुक शुरू नहीं होता है और यदि अंतिम-ऑन-एग्जिट सक्षम किया गया है तो बिन बुलाए फाइनल नहीं चल सकता है। यदि शटडाउन अनुक्रम पहले ही शुरू किया जा चुका है, तो यह विधि किसी भी चालू शटडाउन हुक या फाइनल के लिए इंतजार नहीं करती है।

हालांकि, अंत में जो अपवाद समाप्त हो गया है उसके लिए कोशिश ब्लॉक को "ठीक" नहीं कर सकता है (ध्यान दें, "अधिक" कंसोल के लिए आउटपुट नहीं है)

 public class App { public static void main(String[] args) { try { System.err.println("try"); if (true) {throw new RuntimeException();} } finally { System.err.println("finally"); } System.err.println("more"); } } >> try >> finally >> Exception in thread "main" java.lang.RuntimeException

"अगर (सत्य) {...}" के साथ चाल की आवश्यकता है, क्योंकि अन्यथा संकलक अगम्य कोड (अंतिम पंक्ति) का पता लगाता है और इसे संकलित करने से इनकार करता है

 public class App { public static void main(String[] args) { try { System.err.println("try"); throw new RuntimeException(); } finally { System.err.println("finally"); } System.err.println("more"); } } >> COMPILER ERROR: Unrechable statement

और अंत में यदि ब्लॉक ब्लॉक कॉल रिटर्न ("अधिक" कंसोल के लिए आउटपुट नहीं है) तो विधि को बाहर निकलने से रोक नहीं सकता है "

 public class App { public static void main(String[] args) { try { System.err.println("try"); if (true) {return;} } finally { System.err.println("finally"); } System.err.println("more"); } } >> try >> finally

हालांकि, अंत में एक अन्य थ्रो / रिटर्न के साथ फेंक / वापसी को "मार" सकते हैं

 public class App { public static void main(String[] args) { System.err.println(f()); } public static int f() { try { return 0; } finally { return 1; } } } >> 1

 public class App { public static void main(String[] args) { System.err.println(f()); } public static int f() { try { throw new RuntimeException(); } finally { return 1; } } } >> 1

 public class App { public static void main(String[] args) { System.err.println(f()); } public static int f() { try { return 0; } finally { throw new RuntimeException(); } } } >> Exception in thread "main" java.lang.RuntimeException

 public class App { public static void main(String[] args) { System.err.println(f()); } public static int f() { try { throw new Error(); } finally { throw new RuntimeException(); } } } >> Exception in thread "main" java.lang.RuntimeException

अंतिम कार्रवाई का उपयोग अंतिम कार्रवाई के लिए किया जा सकता है, जिसे कॉल करने की गारंटी दी जाती है (भले ही अपवाद को फेंक दिया गया हो या लेखक ने काम पर वापस लौटाया हो)

 // open some resource try { // use resource } finally { // close resource }

उदाहरण के लिए, कैप्चर किए गए लॉक को रिलीज़ करने के लिए

 Lock lock = new ReentrantLock(); ... lock.lock(); try { // some code } finally { lock.unlock(); }

या एक खुली फाइल स्ट्रीम को बंद करने के लिए

 InputStream input = new FileInputStream("..."); try { // some code } finally { input.close(); }

विशेष रूप से इन उद्देश्यों के लिए, जावा 7 में ट्राय -विथ-रिसोर्स कंस्ट्रक्शन दिखाई दिया, हम बाद में इसका अध्ययन करेंगे।

आम तौर पर बोलना, अंत में खंड में यह मानक रूप से पता लगाना असंभव है कि क्या कोई अपवाद था।

बेशक, आप अपनी खुद की "बाइक" लिखने की कोशिश कर सकते हैं

 public class App { public static void main(String[] args) { System.err.println(f()); } public static int f() { long rnd = System.currenttimeMillis(); boolean finished = false; try { if (rnd % 3 == 0) { throw new Error(); } else if (rnd % 3 == 1) { throw new RuntimeException(); } else { // nothing } finished = true; } finally { if (finished) { //    } else { //  ,  ? } } } }

अनुशंसित अभ्यास नहीं

- अंत में खंड से वापसी (हम प्रयास ब्लॉक से अपवाद मिटा सकते हैं)

- अंत में खंड में क्रियाएँ जो एक अपवाद को फेंक सकती हैं (हम प्रयास ब्लॉक से अपवाद को मिटा सकते हैं)

8.ट्री + कैच + आखिर

कोई अपवाद नहीं

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); // nothing System.err.print(" 1"); } catch(Error e) { System.err.print(" 2"); } finally { System.err.print(" 3"); } System.err.print(" 4"); } } >> 0 1 3 4

हम पकड़ में नहीं जाते हैं, अंत में जाते हैं, बयान के बाद जारी रखें

एक अपवाद है और एक उपयुक्त पकड़ है

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new Error();} System.err.print(" 1"); } catch(Error e) { System.err.print(" 2"); } finally { System.err.print(" 3"); } System.err.print(" 4"); } } >> 0 2 3 4

हम पकड़ में जाते हैं, हम अंत में जाते हैं, हम बयान के बाद जारी रखते हैं,

एक अपवाद है लेकिन कोई उपयुक्त पकड़ नहीं है

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); if (true) {throw new RuntimeException();} System.err.print(" 1"); } catch(Error e) { System.err.print(" 2"); } finally { System.err.print(" 3"); } System.err.print(" 4"); } } >> 0 3 >> RUNTIME ERROR: Exception in thread "main" java.lang.RuntimeException

हम पकड़ में नहीं आते हैं, हम अंत में जाते हैं, हम बयान के बाद जारी नहीं रखते हैं - हम एक बिना किसी अपवाद के बाहर निकलते हैं

9. नेस्टेड कोशिश + पकड़ + अंत में

ऑपरेटर आमतौर पर असीमित घोंसले के शिकार की अनुमति देते हैं।

उदाहरण के साथ अगर

 public class App { public static void main(String[] args) { if (args.length > 1) { if (args.length > 2) { if (args.length > 3) { ... } } } } }

के लिए उदाहरण के साथ

 public class App { public static void main(String[] args) { for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; i++) { for (int k = 0; k < 10; k++) { ... } } } } }

लब्बोलुआब यह है कि कोशिश-कैक्टह-अंत में भी असीमित घोंसले के शिकार की अनुमति देता है।

इस तरह के उदाहरण के लिए

 public class App { public static void main(String[] args) { try { try { try { ... } catch (Exception e) { } finally {} } catch (Exception e) { } finally {} } catch (Exception e) { } finally {} } }

या ऐसे भी

 public class App { public static void main(String[] args) { try { try { ... } catch (Exception e) { ... } finally { ... } } catch (Exception e) { try { ... } catch (Exception e) { ... } finally { ... } } finally { try { ... } catch (Exception e) { ... } finally { ... } } } }

खैर, आइए जानें कि यह कैसे काम करता है।

बिना किसी अपवाद के नेस्टेड-कैच-अंततः

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); try { System.err.print(" 1"); //  System.err.print(" 2"); } catch (RuntimeException e) { System.err.print(" 3"); //   -   } finally { System.err.print(" 4"); //   } System.err.print(" 5"); //  -    } catch (Exception e) { System.err.print(" 6"); //   -   } finally { System.err.print(" 7"); //   } System.err.print(" 8"); //  -    } } >> 0 1 2 4 5 7 8

हम दोनों कैच सेक्शन में नहीं जाते हैं (कोई अपवाद नहीं है), अंत में दोनों सेक्शन में जाते हैं और एफ्टर दोनों लाइनों को अंजाम देते हैं।

नेस्टेड ट्राई-कैच-आखिर एक अपवाद के साथ जो इंटरनल कैच को कैप्चर करेगा

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); try { System.err.print(" 1"); if (true) {throw new RuntimeException();} System.err.print(" 2"); } catch (RuntimeException e) { System.err.print(" 3"); //  -   } finally { System.err.print(" 4"); //   } System.err.print(" 5"); //  -     } catch (Exception e) { System.err.print(" 6"); //   -  ,   } finally { System.err.print(" 7"); //   } System.err.print(" 8"); //  -     } } >> 0 1 3 4 5 7 8

हम FIRST कैच सेक्शन में जाते हैं (प्रिंट "3"), लेकिन सेकंड कैच सेक्शन में न जाएं (प्रिंट न करें "6", क्योंकि अपवाद को पहले पकड़ने से पहले पकड़ लिया जाता है), अंत में दोनों सेक्शन में जाएं (प्रिंट 4) और "7"), दोनों मामलों में हम आखिरकार कोड को निष्पादित करते हैं (हम "5" और "8" प्रिंट करते हैं, क्योंकि अपवाद को पहले पकड़कर रोका गया था)।

नेस्टेड ट्राई-कैच-आखिर एक अपवाद के साथ जो एक बाहरी कैच को कैप्चर करेगा

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); try { System.err.print(" 1"); if (true) {throw new Exception();} System.err.print(" 2"); } catch (RuntimeException e) { System.err.print(" 3"); //   -  ,    } finally { System.err.print(" 4"); //   } System.err.print(" 5"); //   -     } catch (Exception e) { System.err.print(" 6"); //  -    } finally { System.err.print(" 7"); //   } System.err.print(" 8"); //  -     } } >> 0 1 4 6 7 8

हम FIRST कैच सेक्शन में नहीं जाते हैं (“3” प्रिंट नहीं करते हैं), लेकिन SECOND कैच सेक्शन में जाएं (“6” प्रिंट करें), आखिर में दोनों सेक्शन में जाएं (“4” और “7”), FIRST केस में आखिरकार कोड को निष्पादित न करें ("5" प्रिंट न करें, क्योंकि अपवाद बंद नहीं हुआ है), सेकंड मामले में, अंत के बाद कोड निष्पादित करें ("8" प्रिंट करें, क्योंकि अपवाद बंद हो गया है)।

नेस्टेड-कैच-आखिर एक अपवाद के साथ जो कोई भी नहीं होगा

 public class App { public static void main(String[] args) { try { System.err.print(" 0"); try { System.err.print(" 1"); if (true) {throw new Error();} System.err.print(" 2"); } catch (RuntimeException e) { System.err.print(" 3"); //   -  ,    } finally { System.err.print(" 4"); //   } System.err.print(" 5"); //   -     } catch (Exception e) { System.err.print(" 6"); //   -  ,    } finally { System.err.print(" 7"); //   } System.err.print(" 8"); //   -     } } >> 0 1 4 7 >> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error

हम ओबीई कैच सेक्शन में नहीं जाते हैं ("3" और "6" प्रिंट न करें), अंत में दोनों सेक्शन में जाएँ ("4" और "7"), और दोनों ही मामलों में कोड को अंत में निष्पादित न करें (प्रिंट न करें) "5" "और" 8 ", क्योंकि अपवाद बंद नहीं हुआ है), विधि का निष्पादन अपवाद द्वारा बाधित है।

संपर्क विवरण

मैं जावा प्रशिक्षण ऑनलाइन करता हूं (यहां प्रोग्रामिंग पाठ्यक्रम हैं ) और जावा कोर कोर्स के रीडिजाइन के भाग के रूप में प्रशिक्षण सामग्री का हिस्सा प्रकाशित करता हूं। आप YouTube चैनल पर दर्शकों के व्याख्यान की वीडियो रिकॉर्डिंग देख सकते हैं, शायद इस लेख में चैनल का वीडियो बेहतर व्यवस्थित है।

मेरी शिक्षण पद्धति यह है कि मैं

विभिन्न एप्लिकेशन दिखा रहा है
मैं प्रत्येक विकल्प के लिए उदाहरणों का तेजी से जटिल अनुक्रम बना रहा हूं
लेखकों द्वारा संचालित तर्क (जहाँ तक संभव हो) की व्याख्या करें
मैं बड़ी संख्या में परीक्षण (50-100) को व्यापक रूप से समझने और विभिन्न संयोजनों का प्रदर्शन करने के लिए देता हूं
मैं स्वतंत्र काम के लिए प्रयोगशाला देता हूं

यह लेख पैराग्राफ # 1 (विभिन्न विकल्प) और # 2 (प्रत्येक विकल्प के लिए उदाहरण का एक क्रम) का अनुसरण करता है।

स्काइप: गोलोवचक्र्स

ईमेल: GolovachCourses@gmail.com

जावा में अपवाद, भाग I (प्रयास-अंत में पकड़)

1. कीवर्ड: कोशिश, पकड़, अंत में, फेंक, फेंको

2. क्यों System.err का उपयोग करें, System.out का नहीं

3. संकलक को एक वापसी परिणाम की आवश्यकता होती है (या मौन की आवश्यकता होती है)

4. गैर-नियंत्रण नियंत्रण हस्तांतरण

5. कोशिश + पकड़ (पकड़ - बहुरूपी)

6. try + catch + catch + ...

7.ट्री + आखिर

8.ट्री + कैच + आखिर

9. नेस्टेड कोशिश + पकड़ + अंत में

संपर्क विवरण

More articles: