💃🏾 📲 🤔 जावा में अपवाद, भाग II (जाँच / अनियंत्रित) 🐦 ⚫️ 👩🏽‍🎨

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

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

1. जादू की जाँच / अनियंत्रित

2. निराशावादी तंत्र

3. अनियंत्रित (अनकवर्ड) अपवाद के साथ फेंकता है

4. कई अपवाद

5. या पकड़ना, या फेंकना

6. कंपाइलर / जेवीएम व्यवहार

7. ओवरराइडिंग और थ्रो

8. विरासत द्वारा संपत्ति का हस्तांतरण

1. "मैजिक" की जाँच / अनियंत्रित

जावा में असाधारण स्थितियों का तंत्र "जादू" के दो तत्वों से जुड़ा है, अर्थात्। वह स्रोत जो स्रोत कोड में प्रतिबिंबित नहीं होता है:

1. "मैजिक" java.lang.Throwable - थ्रो, कैच और थ्रो में, केवल थ्रोएबल या इसके वारिस खड़े हो सकते हैं ( हम पहले से ही पिछले व्याख्यान में जांच कर चुके हैं )। थ्रो, कैच और थ्रो में होने वाला यह "अधिकार" किसी भी तरह से सोर्स कोड में परिलक्षित नहीं होता है।

2. सभी अपवादों को "जाँच" और "अनियंत्रित" में विभाजित किया गया है। यह गुण rhizome (थ्रोएबल, एरर, एक्सेप्शन, RuntimeException) में निहित है और विरासत में मिला है। स्रोत कोड में अपवाद वर्ग दिखाई नहीं देता है।

आगे के उदाहरणों में, बस यह ध्यान रखें कि

- फेंकने योग्य और अपवाद और उनके सभी वंशज (त्रुटि और रनटाइम अपवाद के उत्तराधिकारियों को छोड़कर) जाँच की गई

- त्रुटि और RuntimeException और उनके सभी वंशज - अनियंत्रित

जाँच अपवाद = संकलक द्वारा जाँच अपवाद जाँच।

वास्तव में कंपाइलर चेक क्या हम इस व्याख्यान में विश्लेषण करेंगे।

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

Object | Throwable / \ Error Exception | RuntimeException

आइए जाँच की गई / अनियंत्रित संपत्ति का मूल्य निर्धारित करें

  Object | Throwable(CHECKED) / \ Error(UNCHECKED) Exception(CHECKED) | RuntimeException(UNCHECKED)

2. निराशावादी तंत्र

मैं चेक किए गए अपवादों के बीच संबंध कहता हूं और "निराशावादी" कहता हूं, हम "डरा" सकते हैं कि पोलिश वास्तव में हो सकता है, लेकिन इसके विपरीत नहीं

हम नहीं छोड़ सकते, लेकिन चेतावनी नहीं देते

 public class App { public static void main(String[] args) { throw new Exception(); //    } } >> COMPILATION ERROR: unhandled exception: java.lang.Exception

हम छोड़ नहीं सकते, लेकिन "कम" की चेतावनी दी

 import java.io.IOException; public class App { public static void main(String[] args) throws IOException { throw new Exception(); //    } } >> COMPILATION ERROR: unhandled exception: java.lang.Exception

हम आपको बता सकते हैं कि हम क्या फेंक रहे हैं

 public class App { public static void main(String[] args) throws Exception { //   Exception throw new Exception(); //   Exception } }

हम जितना फेंक सकते हैं उससे ज्यादा की चेतावनी दे सकते हैं

 public class App { public static void main(String[] args) throws Throwable { //  "" Throwable throw new Exception(); //    Exception } }

हम कुछ के बारे में भी चेतावनी दे सकते हैं जो बिल्कुल भी मौजूद नहीं है

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

यहां तक कि अगर हम इस बारे में चेतावनी देते हैं कि क्या नहीं है, तो सभी को डरना चाहिए

 public class App { public static void main(String[] args) { f(); //    } public static void f() throws Exception { } } >> COMPILATION ERROR: unhandled exception: java.lang.Exception

हालांकि वे (भयभीत) बाकी लोगों को और भी अधिक डरा सकते हैं

 public class App { //    Throwable public static void main(String[] args) throws Throwable { f(); } //    - Exception public static void f() throws Exception { } }

"निराशावाद" का उद्देश्य क्या है? सब कुछ काफी सरल है।

आप प्रोटोटाइप मोड "स्केच" में कहते हैं, इंटरनेट से डाउनलोड करने के लिए एक उपयोगिता वर्ग

 public class InternetDownloader { public static byte[] (String url) throws IOException { return "<html><body>Nothing! It's stub!</body></html>".getBytes(); } }

और अपनी कक्षा के उपयोगकर्ताओं को ALREADY को एक संभावित IOException प्रक्रिया के लिए "बाध्य" करना चाहते हैं, हालाँकि डमी कार्यान्वयन से आप अभी तक ऐसा कोई अपवाद नहीं उत्पन्न करते हैं। लेकिन भविष्य में - जा रहे हैं।

3. अनियंत्रित (अनकवर्ड) अपवाद के साथ फेंकता है

एक ऐसी विधि को कॉल करना जो एक अपवाद द्वारा "डराता" है, वह हम पर कोई ज़िम्मेदारी नहीं डालती है।

 public class App { public static void main(String[] args) { f(); } public static void f() throws RuntimeException { } }

यह निर्माण कोड रीडर को "बताने" के उद्देश्य से कार्य करता है कि आपकी विधि कुछ अनियंत्रित अपवाद को फेंक सकती है।

उदाहरण (java.lang.NumberFormatException - अनियंत्रित अपवाद):

 package java.lang; public final class Integer extends Number implements Comparable<Integer> { ... /** * ... * * @param sa {@code String} containing the {@code int} * representation to be parsed * @return the integer value represented by the argument in decimal. * @exception NumberFormatException if the string does not contain a * parsable integer. */ public static int parseInt(String s) throws NumberFormatException { return parseInt(s,10); } ... }

Integer.parseInt () एक अनुचित तर्क पर एक अनियंत्रित NumberFormatException को फेंक सकता है (int k = Integer.parseInt ("123abc")), यह परिलक्षित होता है

- विधि हस्ताक्षर में: नंबरफ़ॉर्मैट अपवाद को फेंकता है

- प्रलेखन में (javadoc): @ अपवाद

लेकिन यह हमें कुछ भी करने के लिए उपकृत नहीं करता है।

4. कई अपवाद

कोड के साथ एक स्थिति पर विचार करें जो विभिन्न प्रकार के चेक किए गए अपवादों को फेंक सकता है।

इसके अलावा विचार करें कि EOFException और FileNotFoundException IOException के वंशज हैं।

हम वास्तव में इंगित कर सकते हैं कि हम क्या फेंकते हैं

 import java.io.EOFException; import java.io.FileNotFoundException; public class App { //    public static void main(String[] args) throws EOFException, FileNotFoundException { if (System.currentTimeMillis() % 2 == 0) { throw new EOFException(); } else { throw new FileNotFoundException(); } } }

या उस तरह

 import java.io.EOFException; import java.io.FileNotFoundException; public class App { //    public static void main(String[] args) throws EOFException, FileNotFoundException { f0(); f1(); } public static void f0() throws EOFException {...} public static void f1() throws FileNotFoundException {...} }

और हम मजबूत (दोनों अपवादों के पूर्वज) को "डरा" सकते हैं

 import java.io.EOFException; import java.io.FileNotFoundException; import java.io.IOException; public class App { //    public static void main(String[] args) throws IOException { if (System.currentTimeMillis() % 2 == 0) { throw new EOFException(); } else { throw new FileNotFoundException(); } } }

या उस तरह

 import java.io.EOFException; import java.io.FileNotFoundException; public class App { //    public static void main(String[] args) throws IOException { f0(); f1(); } public static void f0() throws EOFException {...} public static void f1() throws FileNotFoundException {...} }

यह इस तरह से संभव है: EOFException और FileNotFoundException "IOException" के लिए सामान्यीकृत हैं, और InterruptedException "छोड़ दिया अछूता" है (InterruptedException IOException का वंशज नहीं है)

 import java.io.EOFException; import java.io.FileNotFoundException; public class App { public static void main(String[] args) throws IOException, InterruptedException { f0(); f1(); f2(); } public static void f0() throws EOFException {...} public static void f1() throws FileNotFoundException {...} public static void f2() throws InterruptedException {...} }

5. या पकड़ना, या फेंकना

आपको डराने की ज़रूरत नहीं है कि आपने अवरोध किया था

इतना

 public class App { public static void main(String[] args) { try { throw new Exception(); } catch (Exception e) { // ... } } }

या तो (हम पूर्वजों और सटीक अवरोधन पर पकड़)

 public class App { public static void main(String[] args) { try { throw new Exception(); } catch (Throwable e) { // ... } } }

लेकिन अगर केवल एक वंशज को रोक दिया गया, तो यह काम नहीं करेगा।

 public class App { public static void main(String[] args) { try { throw new Throwable(); } catch (Exception e) { // ... } } } >> COMPILATION ERROR: unhandled exception: java.lang.Throwable

स्वाभाविक रूप से, "भाई" का अंतरविरोध अच्छा नहीं है

 public class App { public static void main(String[] args) { try { throw new Exception(); } catch (Error e) { // ... } } } >> COMPILATION ERROR: unhandled exception: java.lang.Exception

यदि आपने किसी हिस्से को बाधित किया है, तो आप इसे डरा नहीं सकते

 import java.io.EOFException; import java.io.FileNotFoundException; public class App { // EOFException  catch-,    public static void main(String[] args) throws FileNotFoundException { try { if (System.currentTimeMillis() % 2 == 0) { throw new EOFException(); } else { throw new FileNotFoundException(); } } catch (EOFException e) { // ... } } }

6. कंपाइलर / जेवीएम व्यवहार

इसे समझना होगा

- संकलित अपवाद के समय जाँच होती है (संकलन-समय जाँच)

- रनिंग अपवाद (कैच) रनटाइम पर होता है (रनटाइम चेकिंग)

 public class App { //  Exception public static void main(String[] args) throws Exception { Throwable t = new Exception(); //    Exception throw t; //     } } >> COMPILATION ERROR: unhandled exception: java.lang.Throwable

के साथ पूर्ण सादृश्य

 public class App { public static void main(String[] args) throws Exception { Object ref = "Hello!"; // ref    char c = ref.charAt(0); //     } } >> COMPILATION ERROR: Cannot resolve method 'charAt(int)'

हालांकि संदर्भ लिंक प्रकार java.lang.String (जिसमें एक charAt (int) विधि है) का एक ऑब्जेक्ट इंगित करता है, लिंक का TYPE java.lang.Object है (प्रकार java .lang.Object का एक प्रकार java.lang.String का एक संदर्भ)। संकलक "बाएं प्रकार" (लिंक का प्रकार, लिंक का प्रकार नहीं) पर ध्यान केंद्रित करता है और इस तरह के कोड को छोड़ता नहीं है।

हालांकि SITUATION में, कंपाइलर उस टी का उल्लेख कर सकता है जो अपवाद को संदर्भित करता है, और रेफरी स्ट्रिंग को संदर्भित करता है, लेकिन यह अब अलग संकलन के साथ संभव नहीं है। कल्पना करें कि हम COULD SEPARATELY को इस तरह के एक वर्ग को संकलित करते हैं, एक जार में पैक करते हैं और वितरित करते हैं

 //  !   ! public class App { public static void f0(Throwable t) throws Exception { throw t; } public static void f1(Object ref){ char c = ref.charAt(0); } }

और कोई व्यक्ति इस वर्ग को लेता है, इसे क्लासपाथ में जोड़ता है और App.f0 (new Throwable ()) या App.f1 (new Integer (42)) को कॉल करता है। इस मामले में, जेवीएम एक ऐसी स्थिति का सामना करेगा जहां एक जाँच अपवाद को फेंकना आवश्यक था कि कंपाइलर ने ट्रैक नहीं किया (f0 के मामले में) या एक विधि को कॉल करने के लिए जो (एफ 1 के मामले में) नहीं है!

जावा स्थैतिक टाइपिंग के साथ एक भाषा है (यानी, प्रकारों के सही उपयोग को ट्रैक करना (उपयोग किए गए फ़ील्ड की उपस्थिति, बुलाया विधियों की उपस्थिति, चेक किए गए अपवादों की जांच करना ...) कंपाइलर द्वारा किया जाता है), इस व्यवहार को प्रतिबंधित करता है। कुछ भाषाओं में (डायनेमिक टाइपिंग वाली भाषाएँ - प्रकारों के सही उपयोग की निगरानी रनटाइम द्वारा की जाती है (उदाहरण के लिए, उदाहरण के लिए, जावास्क्रिप्ट में)।

कंपाइलर इस कोड को नहीं छोड़ेगा, हालांकि मुख्य विधि अपवाद नहीं होगी

 public class App { //  Exception public static void main(String[] args) throws Exception { try { Throwable t = new Exception(); //    Exception throw t; //     } catch (Exception e) { System.out.println("!"); } } } >> COMPILATION ERROR: unhandled exception: java.lang.Throwable

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

7. ओवरराइडिंग और थ्रो

ओवरराइड करते समय, वंशानुक्रम अपवाद सूची को पूर्वज के मेल नहीं खाते।

लेकिन यह पूर्वजों की सूची की तुलना में "मजबूत" नहीं होना चाहिए:

 import java.io.FileNotFoundException; import java.io.IOException; public class Parent { //   IOException  InterruptedException public void f() throws IOException, InterruptedException {} } class Child extends Parent { //      IOException @Override public void f() throws FileNotFoundException {} }

हालांकि, यहां हमने फेंके गए अपवादों के "प्रकार का विस्तार" करने की कोशिश की

 import java.io.IOException; public class Parent { public void f() throws IOException, InterruptedException {} } class ChildB extends Parent { @Override public void f() throws Exception {} } >> COMPILATION ERROR: overridden method does not throw 'java.lang.Exception'

आप प्रकार को संकीर्ण क्यों कर सकते हैं, लेकिन विस्तार नहीं?

निम्नलिखित स्थिति पर विचार करें:

 public class Parent { //   Exception public void f() throws Exception {} }

 //     Java, , ,   public class Child extends Parent { //   Exception  Throwable public void f() throws Throwable {} }

 public class Demo { public static void test(Parent ref) { //   , Parent.f()  Exception     catch try { ref.f(); } catch(Exception e) {} } }

 public class App { public static void main(String[] args) { //   , Demo.test  Parent      - Child Demo.test(new Child()); } }

इस उदाहरण पर करीब से नज़र डालें - यदि कोई वंशज पूर्वज के फेंके गए अपवाद के प्रकार का विस्तार कर सकता है, तो उन स्थानों को जो पूर्वज के लिए "प्रतीक्षा" करते हैं और "विस्तारित" वंश का एक उदाहरण प्राप्त करते हैं, अनियंत्रित रूप से अनियंत्रित फेंक सकते हैं

8. विरासत द्वारा संपत्ति का हस्तांतरण

जाँच / अनियंत्रित संपत्ति झंडे के साथ अपवादों के पदानुक्रम को याद करें

  Object | Throwable(CHECKED) / \ Error(UNCHECKED) Exception(CHECKED) | RuntimeException(UNCHECKED)

संपत्ति का स्थान तर्क संबंधित होने के लिए संबंधित नहीं है। हम इस तर्क पर बाद में (निम्नलिखित लेखों में) विचार करेंगे।

हालाँकि, कस्टम अपवाद वर्गों की जाँच की गई / अनियंत्रित संपत्ति EXCLUSIVELY आधार पर निर्मित है।

नियम बेहद सरल है:

1. यदि सूची से अपवाद थ्रोबेबल, त्रुटि, अपवाद, रनटाइम एक्सेप्शन है - तो आपकी संपत्ति जिसे आपको याद रखने की आवश्यकता है।

2. यदि आप सूची से नहीं हैं, तो आपकी संपत्ति पूर्वज की संपत्ति के बराबर है। यहां विरासत को तोड़ना असंभव है।

यदि हम वंशजों A, B, C, D, E, F, G, H, I, J, K, L को जन्म देते हैं, जो "प्रकंद" (निम्न, त्रुटि, अपवाद, RimeimeException) से निम्नानुसार विरासत में मिले हैं, तो उनकी जाँच की गई संपत्ति का मूल्य / अनियंत्रित आरेख में देखा जा सकता है

  Object | Throwable(CHECKED) / | \ Error(UNCHECKED) | Exception(CHECKED) | | | | | A(UNC) D(UNC) | F(C) RuntimeException(UNCHECKED) / \ | / \ | | B(UNC) C(UNC) | G(C) H(C) I(UNC) J(UNC) E(C) / \ K(UNC) L(UNC)

संपर्क विवरण

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

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

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

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

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

ईमेल: GolovachCourses@gmail.com

जावा में अपवाद, भाग II (जाँच / अनियंत्रित)