जावा में अपवाद

नमस्ते! आज के पाठ में हम जावा अपवादों के बारे में बात करेंगे। रोजमर्रा की जिंदगी ऐसी परिस्थितियों से भरी होती है जिसकी हम कल्पना नहीं करते हैं। उदाहरण के लिए, आप सुबह काम के लिए उठते हैं और अपने फोन का चार्जर ढूंढते हैं, लेकिन वह आपको कहीं नहीं मिलता। आप नहाने के लिए बाथरूम जाते हैं तो आपको पता चलता है कि पाइप जम गए हैं। आप अपनी कार में बैठो, लेकिन यह शुरू नहीं होगी। मनुष्य ऐसी अप्रत्याशित परिस्थितियों का सामना आसानी से कर लेता है। इस लेख में, हम यह पता लगाने की कोशिश करेंगे कि जावा प्रोग्राम उनसे कैसे निपटते हैं।

जावा अपवाद क्या है?

प्रोग्रामिंग की दुनिया में, किसी प्रोग्राम के निष्पादन में होने वाली त्रुटियों और अप्रत्याशित स्थितियों को अपवाद कहा जाता है। किसी प्रोग्राम में, अमान्य उपयोगकर्ता क्रियाओं, अपर्याप्त डिस्क स्थान, या सर्वर के साथ नेटवर्क कनेक्शन के नुकसान के कारण अपवाद हो सकते हैं। अपवाद प्रोग्रामिंग त्रुटियों या एपीआई के गलत उपयोग से भी हो सकते हैं। वास्तविक दुनिया में मनुष्यों के विपरीत, एक कार्यक्रम को यह पता होना चाहिए कि इन स्थितियों को कैसे संभालना है। इसके लिए, जावा में एक तंत्र है जिसे एक्सेप्शन हैंडलिंग के रूप में जाना जाता है।

कीवर्ड के बारे में कुछ शब्द

जावा में एक्सेप्शन हैंडलिंग प्रोग्राम में निम्नलिखित कीवर्ड के उपयोग पर आधारित है:

• कोशिश - कोड के एक ब्लॉक को परिभाषित करता है जहां अपवाद हो सकता है;
• पकड़ - कोड के एक ब्लॉक को परिभाषित करता है जहां अपवादों को नियंत्रित किया जाता है;
• अंत में - कोड के एक वैकल्पिक ब्लॉक को परिभाषित करता है, जो कि मौजूद होने पर, कोशिश ब्लॉक के परिणामों की परवाह किए बिना निष्पादित किया जाता है।

कोड में विशेष निर्माण करने के लिए इन खोजशब्दों का उपयोग किया जाता है: कोशिश करें {}पकड़ें , कोशिश करें{}पकड़ें{}आखिरकार , कोशिश करें{}आखिरकार{} ।

• फेंक - अपवाद उठाने के लिए प्रयोग किया जाता है;
• फेंकता - विधि हस्ताक्षर में चेतावनी देने के लिए प्रयोग किया जाता है कि विधि अपवाद फेंक सकती है।

जावा प्रोग्राम में कीवर्ड का उपयोग करने का एक उदाहरण:

// This method reads a string from the keyboard

public String input() throws MyException { // Use throws to warn 
// that the method may throw a MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// We use a try block to wrap code that might create an exception. In this case,
// the compiler tells us that the readLine() method in the 
// BufferedReader class might throw an I/O exception
    try {
        s = reader.readLine();
// We use a catch block to wrap the code that handles an IOException  
    } catch (IOException e) {
        System.out.println(e.getMessage());
// We close the read stream in the finally block
    } finally {
// An exception might occur when we close the stream if, for example, the stream was not open, so we wrap the code in a try block
        try {
            reader.close();
// Handle exceptions when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// We've decided that an empty string will prevent our program from working properly. For example, we use the result of this method to call the substring(1, 2) method. Accordingly, we have to interrupt the program by using throw to generate our own MyException exception type.
        throw new MyException("The string cannot be empty!");
    }
    return s;
}

हमें अपवादों की आवश्यकता क्यों है?

आइए वास्तविक दुनिया से एक उदाहरण देखें। कल्पना कीजिए कि राजमार्ग के एक हिस्से में सीमित भार क्षमता वाला एक छोटा पुल है। यदि कोई कार पुल की सीमा से अधिक भारी हो जाती है, तो वह गिर सकती है। इसे हल्के ढंग से रखने के लिए ड्राइवर के लिए स्थिति असाधारण हो जाएगी। इससे बचने के लिए परिवहन विभाग कुछ भी गलत होने से पहले सड़क पर चेतावनी बोर्ड लगा देता है। चेतावनी के संकेत को देखकर, चालक अपने वाहन के वजन की तुलना पुल के अधिकतम वजन से करता है। यदि वाहन बहुत भारी है, तो चालक बायपास का रास्ता अपनाता है। परिवहन विभाग ने सबसे पहले ट्रक ड्राइवरों के लिए आवश्यक होने पर अपना मार्ग बदलना संभव बनाया, दूसरा, ड्राइवरों को मुख्य सड़क पर खतरों के बारे में चेतावनी दी, और तीसरे, ड्राइवरों को चेतावनी दी कि कुछ शर्तों के तहत पुल का उपयोग नहीं किया जाना चाहिए। किसी प्रोग्राम में असाधारण स्थितियों को रोकने और हल करने की क्षमता, इसे चालू रखने की अनुमति देना, जावा में अपवादों का उपयोग करने का एक कारण है। अपवाद तंत्र आपको किसी भी इनपुट को सत्यापित (जांच) करके अपने कोड (एपीआई) को अनुचित उपयोग से बचाने देता है। अब कल्पना कीजिए कि आप एक सेकंड के लिए परिवहन विभाग हैं। सबसे पहले, आपको उन जगहों को जानने की जरूरत है जहां मोटर यात्री परेशानी की उम्मीद कर सकते हैं। दूसरा, आपको चेतावनी संकेत बनाने और स्थापित करने की आवश्यकता है। और अंत में, यदि मुख्य मार्ग पर समस्याएँ आती हैं तो आपको चक्कर लगाने की आवश्यकता है। जावा में, अपवाद तंत्र इसी तरह काम करता है। विकास के दौरान, हम कोड के खतरनाक वर्गों के आसपास "अपवाद अवरोध" बनाने के लिए एक प्रयास ब्लॉक का उपयोग करते हैं, हम कैच {} का उपयोग करके "बैकअप मार्ग" प्रदान करते हैंब्लॉक करें, और हम कोड लिखते हैं जो अंत में {} ब्लॉक में कोई फर्क नहीं पड़ता । यदि हम "बैकअप मार्ग" प्रदान नहीं कर सकते हैं या हम उपयोगकर्ता को चुनने का अधिकार देना चाहते हैं, तो हमें कम से कम उसे खतरे से आगाह करना चाहिए। क्यों? ज़रा उस ड्राइवर के आक्रोश की कल्पना करें, जो एक भी चेतावनी संकेत देखे बिना, एक छोटे से पुल पर पहुँच जाता है जिसे वह पार नहीं कर सकता! प्रोग्रामिंग में, अपनी कक्षाओं और विधियों को लिखते समय, हम हमेशा यह नहीं देख सकते हैं कि अन्य डेवलपर्स द्वारा उनका उपयोग कैसे किया जा सकता है। नतीजतन, हम असाधारण स्थिति को हल करने के लिए 100% सही तरीके की कल्पना नहीं कर सकते हैं। उस ने कहा, असाधारण स्थितियों की संभावना के बारे में दूसरों को चेतावनी देना अच्छा है। जावा का अपवाद तंत्र हमें थ्रो के साथ ऐसा करने देता हैकीवर्ड - अनिवार्य रूप से एक घोषणा है कि हमारी पद्धति के सामान्य व्यवहार में एक अपवाद फेंकना शामिल है। इस प्रकार, विधि का उपयोग करने वाला कोई भी व्यक्ति जानता है कि उसे अपवादों को संभालने के लिए कोड लिखना चाहिए।

दूसरों को "मुसीबत" के बारे में चेतावनी देना

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

अपवाद पदानुक्रम

जब कोई प्रोग्राम चलते समय कोई त्रुटि होती है, तो JVM जावा अपवाद पदानुक्रम से उपयुक्त प्रकार का एक ऑब्जेक्ट बनाता है - संभावित अपवादों का एक सेट जो एक सामान्य पूर्वज - थ्रोएबल क्लास से उतरता है । हम असाधारण रनटाइम स्थितियों को दो समूहों में विभाजित कर सकते हैं:

1. ऐसी स्थितियाँ जिनसे प्रोग्राम ठीक नहीं हो सकता और सामान्य संचालन जारी रख सकता है।
2. ऐसी स्थितियाँ जहाँ पुनर्प्राप्ति संभव है।

पहले समूह में अपवाद शामिल स्थितियां शामिल हैं जो त्रुटि वर्ग से निकलती हैं। ये ऐसी त्रुटियाँ हैं जो JVM की खराबी, मेमोरी ओवरफ़्लो या सिस्टम विफलता के कारण होती हैं। वे आमतौर पर गंभीर समस्याओं का संकेत देते हैं जिन्हें सॉफ़्टवेयर द्वारा ठीक नहीं किया जा सकता है। जावा में, ऐसे अपवादों की संभावना को संकलक द्वारा जांचा नहीं जाता है, इसलिए उन्हें अनियंत्रित अपवाद के रूप में जाना जाता है। इस समूह में रनटाइम अपवाद भी शामिल हैं, जो अपवाद हैं जो अपवाद से उतरते हैंक्लास और JVM द्वारा रन टाइम पर जेनरेट किया जाता है। वे अक्सर प्रोग्रामिंग त्रुटियों के कारण होते हैं। संकलन के समय इन अपवादों को भी चेक (अनियंत्रित) नहीं किया जाता है, इसलिए आपको उन्हें संभालने के लिए कोड लिखने की आवश्यकता नहीं है। दूसरे समूह में असाधारण परिस्थितियाँ शामिल हैं जिन्हें प्रोग्राम लिखते समय पहले से ही देखा जा सकता है (और इस प्रकार आपको उन्हें संभालने के लिए कोड लिखना चाहिए)। ऐसे अपवादों को चेक अपवाद कहा जाता है। जब अपवादों की बात आती है, तो जावा डेवलपर का अधिकांश काम ऐसी स्थितियों को संभालना होता है।

एक अपवाद बनाना

जब कोई प्रोग्राम चलता है, तो JVM द्वारा या मैन्युअल रूप से थ्रो स्टेटमेंट का उपयोग करके अपवाद उत्पन्न होते हैं। जब ऐसा होता है, स्मृति में एक अपवाद वस्तु बनाई जाती है, प्रोग्राम का मुख्य प्रवाह बाधित होता है, और JVM का अपवाद हैंडलर अपवाद को संभालने का प्रयास करता है।

एक्सेप्शन हेंडलिंग

जावा में, हम कोड ब्लॉक बनाते हैं जहां हम कोशिश {}कैच , ट्राई {}कैच {}अंत में , और कोशिश{}आखिरकार{} के निर्माण का उपयोग करके अपवाद से निपटने की आवश्यकता का अनुमान लगाते हैं। जब किसी ट्राई ब्लॉक में एक अपवाद फेंका जाता है , तो JVM अगले कैच ब्लॉक में एक उपयुक्त अपवाद हैंडलर की तलाश करता है। यदि किसी कैच ब्लॉक में आवश्यक अपवाद हैंडलर है, तो नियंत्रण उसके पास जाता है। यदि नहीं, तो उपयुक्त हैंडलर मिलने तक जेवीएम कैच ब्लॉक की श्रृंखला को और नीचे देखता है। कैच ब्लॉक को निष्पादित करने के बाद , नियंत्रण वैकल्पिक अंत में ब्लॉक में स्थानांतरित हो जाता है। अगर एक उपयुक्त कैचब्लॉक नहीं मिला है, तो JVM प्रोग्राम को रोक देता है और स्टैक ट्रेस (विधि कॉल का वर्तमान स्टैक) प्रदर्शित करता है, यदि यह मौजूद है तो पहले अंत में ब्लॉक करने के बाद। अपवाद हैंडलिंग का उदाहरण:

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside print method: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s : list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception handled. The program will continue");
            }
            finally {
                System.out.println("Inside finally block");
            }
            System.out.println("The program is running...");
            System.out.println("-----------------");
        }

    }
    }

यहाँ मुख्य विधि के परिणाम हैं :

Inside print method: first step
Inside finally block
The program is running...
-----------------
Exception: s is null!
Exception handled. The program will continue
Inside finally block
The program is running...
-----------------
Inside print method: second step
Inside finally block
The program is running...
-----------------

अंत में आमतौर पर किसी भी स्ट्रीम को बंद करने और कोशिश ब्लॉक में खोले/आवंटित किसी भी संसाधन को मुक्त करने के लिए उपयोग किया जाता है। हालाँकि, प्रोग्राम लिखते समय, सभी संसाधनों के बंद होने का ट्रैक रखना हमेशा संभव नहीं होता है। हमारे जीवन को आसान बनाने के लिए, जावा के डेवलपर्स कोशिश-के-संसाधनों के निर्माण की पेशकश करते हैं, जो एक कोशिश ब्लॉक में खोले गए किसी भी संसाधन को स्वचालित रूप से बंद कर देता है। हमारा पहला उदाहरण try-with-resources के साथ फिर से लिखा जा सकता है :

public String input() throws MyException {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")) {
        throw new MyException ("The string cannot be empty!");
    }
    return s;
}

संस्करण 7 में शुरू की गई जावा क्षमताओं के लिए धन्यवाद, हम विषम अपवादों को पकड़ने के लिए एक ब्लॉक में भी जोड़ सकते हैं, जिससे कोड अधिक कॉम्पैक्ट और पठनीय हो जाता है। उदाहरण:

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("The string cannot be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

तल - रेखा

जावा में अपवादों का उपयोग करने से आप "बैकअप मार्ग" बनाकर अपने प्रोग्राम को और अधिक मजबूत बना सकते हैं, मुख्य कोड को अपवाद हैंडलिंग कोड से अलग करने के लिए कैच ब्लॉक का उपयोग करें, और जो कोई भी आपकी विधि का उपयोग करता है, अपवाद हैंडलिंग की जिम्मेदारी स्थानांतरित करने के लिए थ्रो का उपयोग करें।