पेश है अपवाद

"हाय, अमीगो। आज हमारे पास एक बहुत ही दिलचस्प पाठ है। मैं आपको अपवादों के बारे में बताने जा रहा हूं। अपवाद एक विशेष तंत्र है जो हमें कार्यक्रम में त्रुटियों को संभालने देता है। यहां त्रुटियों के कुछ उदाहरण हैं जो हो सकते हैं। एक कार्यक्रम में:

1. हार्ड ड्राइव पूरी तरह से भर जाने पर प्रोग्राम फ़ाइल लिखने का प्रयास कर सकता है।

2. कार्यक्रम एक अशक्त संदर्भ को संग्रहीत करने वाले चर पर एक विधि को कॉल करने का प्रयास कर सकता है।

3. प्रोग्राम किसी संख्या को 0 से विभाजित करने का प्रयास कर सकता है।"

इन सभी क्रियाओं के परिणामस्वरूप त्रुटियाँ होती हैं। आमतौर पर, परिणाम यह होता है कि प्रोग्राम तुरंत समाप्त हो जाता है, क्योंकि इस मामले में कोड को निष्पादित करना जारी रखने का कोई मतलब नहीं है।

"क्यों?"

"क्या यह समझ में आता है कि अगर कार सड़क से हट गई है और चट्टान से गिर रही है तो पहिया घुमाते रहना चाहिए?"

"क्या कार्यक्रम चलना बंद कर देना चाहिए, फिर?"

"हाँ। कम से कम, यही हुआ करता था। किसी भी त्रुटि के कारण कार्यक्रम समाप्त हो गया।"

"यह एक बहुत ही स्मार्ट तरीका है।"

"लेकिन क्या कोशिश करना और कार्यक्रम चलाना जारी रखना बेहतर नहीं होगा?"

"हाँ। मान लीजिए कि आपने वर्ड में बड़ी मात्रा में टेक्स्ट टाइप किया है और इसे सेव किया है। क्या होगा अगर सेव ऑपरेशन विफल हो जाए, लेकिन प्रोग्राम आपको विश्वास दिलाता है कि सब कुछ ठीक है? और आप टाइप करते चले जाते हैं। यह बेवकूफी होगी, नहीं होगी।" यह?"

"हां।"

"फिर प्रोग्रामर एक दिलचस्प समाधान के साथ आए: प्रत्येक फ़ंक्शन अपने काम की स्थिति लौटाएगा। 0 का मतलब है कि यह उम्मीद के मुताबिक काम करता है। किसी अन्य मूल्य का मतलब होगा कि कुछ त्रुटि हुई, और वापसी मूल्य एक त्रुटि कोड था।"

"हालांकि, उस दृष्टिकोण में इसकी कमियां भी हैं। प्रत्येक (!) फ़ंक्शन कॉल के बाद, आपको रिटर्न कोड (संख्या) की जांच करनी होगी। सबसे पहले, यह असुविधाजनक है: त्रुटि-हैंडलिंग कोड को शायद ही कभी निष्पादित किया जाता है लेकिन इसे शामिल करने की आवश्यकता होती है हर जगह। दूसरा, फ़ंक्शन अक्सर अलग-अलग मान लौटाते हैं - आप उनके साथ क्या करने वाले हैं?"

"ठीक है। मैंने भी उसके बारे में सोचा।"

"फिर, एक उज्ज्वल भविष्य अपवादों और एक त्रुटि से निपटने के तंत्र के रूप में आया। यहां बताया गया है कि यह कैसे काम करता है:

1. जब कोई त्रुटि होती है, तो जावा मशीन एक विशेष वस्तु - एक अपवाद - बनाती है जहां यह सभी त्रुटि जानकारी सहेजती है। अलग-अलग त्रुटियों के लिए अलग-अलग अपवाद हैं।

2. एक अपवाद प्रोग्राम को वर्तमान फ़ंक्शन और अगले फ़ंक्शन से तुरंत बाहर निकलने का कारण बनता है, और इसी तरह - जब तक कि यह मुख्य विधि से बाहर नहीं निकलता। फिर कार्यक्रम समाप्त हो जाता है। प्रोग्रामर यह भी कह सकते हैं कि जावा मशीन 'कॉल स्टैक को खोलती है'।"

"लेकिन आपने कहा था कि कार्यक्रम हमेशा समाप्त नहीं होता है।"

"हाँ, क्योंकि एक अपवाद को पकड़ने का एक तरीका है। हम उन अपवादों को पकड़ने के लिए और उनके साथ कुछ करने के लिए सही जगह पर विशेष कोड लिख सकते हैं। यह महत्वपूर्ण सामान है।"

"ऐसा करने में हमारी मदद करने के लिए, एक विशेष ट्राइ-कैच संरचना है । यहां बताया गया है कि यह कैसे काम करता है:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (Exception e)
        {
           System.out.println("Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

Program starts
Before method1 calling
Exception has been caught
Program is still running

"लेकिन 'मेथड 1 कॉल करने के बाद। यह कभी नहीं दिखाया जाएगा' स्क्रीन पर प्रदर्शित क्यों नहीं होगा?"

"मुझे खुशी है कि आपने पूछा। लाइन 25 में, हम 0 से विभाजित करते हैं, जो एक त्रुटि - एक अपवाद की ओर जाता है। जावा मशीन त्रुटि के बारे में जानकारी के साथ एक अंकगणितीय अपवाद वस्तु बनाती है। वस्तु अपवाद है।"

"अपवाद method1विधि के अंदर होता है। यह विधि को तुरंत समाप्त करने का कारण बनता है। यह मुख्य विधि को समाप्त करने का कारण होगा यदि ट्राई-कैच ब्लॉक के लिए नहीं।"

"यदि एक प्रयास ब्लॉक के अंदर एक अपवाद होता है, तो यह कैच ब्लॉक में पकड़ा जाता है। कोशिश ब्लॉक में शेष कोड को निष्पादित नहीं किया जाएगा। इसके बजाय, कैच ब्लॉक को निष्पादित करना शुरू हो जाएगा। "

"मैं समझा नहीं।"

"दूसरे शब्दों में, कोड इस तरह काम करता है:

1. यदि एक प्रयास ब्लॉक के अंदर एक अपवाद होता है , तो कोड निष्पादित होना बंद हो जाता है जहां अपवाद हुआ और कैच ब्लॉक निष्पादित होना शुरू हो गया।

2. यदि कोई अपवाद नहीं होता है, तो कोशिश ब्लॉक को अंत तक निष्पादित किया जाता है और कैच ब्लॉक को निष्पादित नहीं किया जाता है । "

"हुह?"

"कल्पना करें कि प्रत्येक विधि कॉल के बाद हम जांचते हैं कि क्या विधि सामान्य रूप से वापस आ गई है या अपवाद के परिणामस्वरूप अचानक समाप्त हो गई है। यदि कोई अपवाद है, तो हम अपवाद को पकड़ने के लिए कैच ब्लॉक (यदि कोई है) को निष्पादित करने के लिए आगे बढ़ते हैं। यदि कोई कैच ब्लॉक नहीं है, तो हम वर्तमान विधि को समाप्त कर देते हैं, और जिस विधि ने हमें कॉल किया है, वही जाँच करता है।"

"मुझे लगता है कि मुझे अब मिल गया है।"

"उत्कृष्ट।"

"कैच स्टेटमेंट के अंदर 'अपवाद' का क्या अर्थ है?"

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

"कूल! अगर मेरे तरीके में अलग-अलग अपवाद होते हैं, तो क्या मैं उन्हें अलग तरीके से प्रोसेस कर सकता हूं?"

"न केवल आप कर सकते हैं, बल्कि आपको करना चाहिए। आप इसे इस तरह कर सकते हैं:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (NullPointerException e)
        {
           System.out.println("Null reference. Exception has been caught");
        }
        catch (ArithmeticException e)
        {
            System.out.println("Division by zero. Exception has been caught");
        }
        catch (Exception e)
        {
            System.out.println("Any other errors. Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

" कोशिश ब्लॉक को कई कैच ब्लॉक के साथ जोड़ा जा सकता है, जिनमें से प्रत्येक निर्दिष्ट प्रकार के अपवादों को पकड़ लेगा।"

"मुझे लगता है कि मैं समझ गया हूं। मैं इसे अभी खुद नहीं लिख सकता, लेकिन अगर मैं इसे कोड में देखता हूं, तो मुझे डर नहीं लगेगा।"