Java मधील अपवाद

नमस्कार! आजच्या धड्यात, आपण जावा अपवादांबद्दल बोलू. दैनंदिन जीवन अशा परिस्थितींनी भरलेले असते ज्याची आपण अपेक्षा करत नाही. उदाहरणार्थ, तुम्ही सकाळी कामासाठी उठता आणि तुमचा फोन चार्जर शोधता, परंतु तुम्हाला तो कुठेही सापडत नाही. पाईप्स गोठलेले आहेत हे शोधण्यासाठी तुम्ही शॉवरसाठी बाथरूममध्ये जाता. तुम्ही तुमच्या कारमध्ये बसा, पण ती सुरू होणार नाही. माणूस अशा अप्रत्याशित परिस्थितीला अगदी सहजपणे तोंड देऊ शकतो. या लेखात, आम्ही जावा प्रोग्राम त्यांच्याशी कसे व्यवहार करतो हे शोधण्याचा प्रयत्न करू.

Java अपवाद काय आहे?

प्रोग्रामिंग जगात, प्रोग्रामच्या अंमलबजावणीमध्ये त्रुटी आणि अनपेक्षित परिस्थितींना अपवाद म्हणतात. प्रोग्राममध्ये, वापरकर्त्याच्या अवैध क्रिया, अपुरी डिस्क स्पेस किंवा सर्व्हरसह नेटवर्क कनेक्शन गमावल्यामुळे अपवाद येऊ शकतात. प्रोग्रामिंग त्रुटी किंवा API च्या चुकीच्या वापरामुळे अपवाद देखील होऊ शकतात. वास्तविक जगातील मानवांप्रमाणेच, या परिस्थितींना कसे हाताळायचे हे प्रोग्रामला माहित असणे आवश्यक आहे. यासाठी Java कडे अपवाद हाताळणी म्हणून ओळखली जाणारी यंत्रणा आहे.

कीवर्डबद्दल काही शब्द

Java मधील अपवाद हाताळणी प्रोग्राममधील खालील कीवर्डच्या वापरावर आधारित आहे:

• प्रयत्न करा - कोडचा एक ब्लॉक परिभाषित करते जेथे अपवाद येऊ शकतो;
• पकड - कोडचा एक ब्लॉक परिभाषित करते जेथे अपवाद हाताळले जातात;
• शेवटी - कोडचा एक पर्यायी ब्लॉक परिभाषित करतो जो, जर असेल तर, ट्राय ब्लॉकच्या परिणामांची पर्वा न करता अंमलात आणला जातो.

कोडमध्ये विशेष रचना तयार करण्यासाठी हे कीवर्ड वापरले जातात: प्रयत्न करा{}कॅच करा , प्रयत्न करा{}कॅच{}शेवटी , प्रयत्न करा{}शेवटी{} .

• फेकणे - अपवाद वाढविण्यासाठी वापरले जाते;
• थ्रो - पद्धत अपवाद दर्शवू शकते याची चेतावणी देण्यासाठी पद्धत स्वाक्षरीमध्ये वापरली जाते.

Java प्रोग्राममध्ये कीवर्ड वापरण्याचे उदाहरण:

// 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;
}

आम्हाला अपवादांची गरज का आहे?

वास्तविक जगाचे उदाहरण पाहू. कल्पना करा की महामार्गाच्या एका भागात मर्यादित वजन क्षमता असलेला छोटा पूल आहे. पुलाच्या मर्यादेपेक्षा जड गाडी त्यावरून गेल्यास ती कोसळू शकते. ड्रायव्हरची परिस्थिती सौम्यपणे सांगायचे तर अपवादात्मक होईल. हे टाळण्यासाठी वाहतूक विभाग काही चूक होण्यापूर्वीच रस्त्यावर धोक्याची सूचना देणारे फलक लावतात. चेतावणी चिन्ह पाहून, ड्रायव्हर त्याच्या वाहनाच्या वजनाची पुलाच्या जास्तीत जास्त वजनाशी तुलना करतो. वाहन खूप जड असल्यास, चालक बायपास मार्गाचा अवलंब करतो. परिवहन विभागाने, प्रथम, ट्रक चालकांना आवश्यक असल्यास त्यांचा मार्ग बदलणे शक्य केले, दुसरे, मुख्य रस्त्यावरील धोक्यांबद्दल चालकांना चेतावणी दिली आणि तिसरे, काही विशिष्ट परिस्थितीत पुलाचा वापर करू नये असा इशारा चालकांना दिला. प्रोग्रॅममधील अपवादात्मक परिस्थिती टाळण्यासाठी आणि त्याचे निराकरण करण्याची क्षमता, त्याला चालू ठेवण्याची परवानगी देणे, हे Java मधील अपवाद वापरण्याचे एक कारण आहे. अपवाद यंत्रणा तुम्हाला तुमच्या कोडचे (API) कोणत्याही इनपुटचे प्रमाणीकरण (तपासणे) करून अयोग्य वापरापासून संरक्षण करू देते. आता कल्पना करा की तुम्ही एका सेकंदासाठी वाहतूक विभाग आहात. प्रथम, आपल्याला अशी ठिकाणे माहित असणे आवश्यक आहे जिथे वाहनचालक त्रासाची अपेक्षा करू शकतात. दुसरे, आपल्याला चेतावणी चिन्हे तयार करणे आणि स्थापित करणे आवश्यक आहे. आणि शेवटी, मुख्य मार्गावर समस्या उद्भवल्यास, तुम्हाला वळसा घालणे आवश्यक आहे. Java मध्ये, अपवाद यंत्रणा अशाच प्रकारे कार्य करते. विकासादरम्यान, कोडच्या धोकादायक विभागांभोवती "अपवाद अडथळे" तयार करण्यासाठी आम्ही ट्राय ब्लॉक वापरतो, आम्ही कॅच वापरून "बॅकअप मार्ग" प्रदान करतो {}ब्लॉक करा, आणि आम्ही कोड लिहितो जो शेवटी{} ब्लॉकमध्ये काहीही असला तरी चालला पाहिजे . आम्ही "बॅकअप मार्ग" प्रदान करू शकत नसल्यास किंवा वापरकर्त्याला निवडण्याचा अधिकार देऊ इच्छित असल्यास, आम्ही किमान त्याला किंवा तिला धोक्याची चेतावणी दिली पाहिजे. का? एका ड्रायव्हरच्या रागाची कल्पना करा, जो एकही इशारा न पाहता, तो ओलांडू शकत नाही अशा छोट्या पुलावर पोहोचतो! प्रोग्रामिंगमध्ये, आमचे वर्ग आणि पद्धती लिहिताना, इतर विकसकांद्वारे ते कसे वापरले जातील याचा आम्ही नेहमी अंदाज लावू शकत नाही. परिणामी, आम्ही अपवादात्मक परिस्थितीचे निराकरण करण्यासाठी 100% योग्य मार्गाचा अंदाज लावू शकत नाही. ते म्हणाले, अपवादात्मक परिस्थितीच्या शक्यतेबद्दल इतरांना चेतावणी देणे हा एक चांगला प्रकार आहे. Java ची अपवाद यंत्रणा आपल्याला हे थ्रो सह करू देतेकीवर्ड — मूलत: एक घोषणा आहे की आमच्या पद्धतीच्या सामान्य वर्तनामध्ये अपवाद फेकणे समाविष्ट आहे. अशा प्रकारे, पद्धत वापरणाऱ्या कोणालाही माहित आहे की त्याने अपवाद हाताळण्यासाठी कोड लिहावा.

इतरांना "त्रास" बद्दल चेतावणी देणे

तुम्‍ही तुमच्‍या पद्धतीमध्‍ये अपवाद हाताळण्‍याची योजना करत नसल्‍यास, परंतु इतरांना चेतावणी द्यायची असेल की अपवाद येऊ शकतात, तर थ्रो कीवर्ड वापरा . मेथड सिग्नेचरमधील या कीवर्डचा अर्थ असा आहे की, काही विशिष्ट परिस्थितींमध्ये, पद्धत अपवाद दर्शवू शकते. ही चेतावणी पद्धत इंटरफेसचा भाग आहे आणि त्याच्या वापरकर्त्यांना त्यांचे स्वतःचे अपवाद हाताळणी तर्क लागू करू देते. फेकल्यानंतर, आम्ही फेकलेल्या अपवादांचे प्रकार निर्दिष्ट करतो. हे सहसा Java च्या अपवाद वर्गातून येतात. Java ही ऑब्जेक्ट ओरिएंटेड भाषा असल्याने, सर्व अपवाद Java मधील ऑब्जेक्ट्स आहेत.

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

जेव्हा एखादा प्रोग्राम चालू असताना एरर येते, तेव्हा JVM Java अपवाद पदानुक्रमातून योग्य प्रकारची ऑब्जेक्ट तयार करते — संभाव्य अपवादांचा एक संच जो सामान्य पूर्वजापासून येतो — थ्रोएबल क्लास . आम्ही अपवादात्मक रनटाइम परिस्थिती दोन गटांमध्ये विभागू शकतो:

1. ज्या परिस्थितीत प्रोग्राम पुनर्प्राप्त करू शकत नाही आणि सामान्य ऑपरेशन चालू ठेवू शकत नाही.
2. ज्या परिस्थितीत पुनर्प्राप्ती शक्य आहे.

पहिल्या गटामध्ये त्रुटी वर्गातून आलेल्या अपवादाचा समावेश असलेल्या परिस्थितींचा समावेश होतो. JVM खराबी, मेमरी ओव्हरफ्लो किंवा सिस्टीम अयशस्वी झाल्यामुळे या त्रुटी आहेत. ते सहसा गंभीर समस्या दर्शवतात ज्या सॉफ्टवेअरद्वारे निश्चित केल्या जाऊ शकत नाहीत. Java मध्ये, अशा अपवादांची शक्यता कंपाइलरद्वारे तपासली जात नाही, म्हणून त्यांना अनचेक अपवाद म्हणून ओळखले जाते. या गटामध्ये RuntimeExceptions देखील समाविष्ट आहेत, जे अपवाद पासून उतरलेले अपवाद आहेतवर्ग आणि JVM द्वारे रन टाइमवर व्युत्पन्न केले जातात. ते सहसा प्रोग्रामिंग त्रुटींमुळे होतात. हे अपवाद देखील संकलित वेळी तपासलेले (अनचेक केलेले) नाहीत, म्हणून तुम्हाला ते हाताळण्यासाठी कोड लिहिण्याची आवश्यकता नाही. दुसर्‍या गटात अपवादात्मक परिस्थितींचा समावेश आहे ज्याचा तुम्ही प्रोग्राम लिहिताना अंदाज लावला जाऊ शकतो (आणि अशा प्रकारे तुम्ही त्यांना हाताळण्यासाठी कोड लिहावा). अशा अपवादांना चेक केलेले अपवाद म्हणतात. अपवादांचा विचार केल्यास, जावा डेव्हलपरचे बहुतेक काम अशा परिस्थिती हाताळत असते.

अपवाद निर्माण करणे

जेव्हा एखादा प्रोग्राम चालतो, तेव्हा JVM द्वारे किंवा व्यक्तिचलितपणे थ्रो स्टेटमेंट वापरून अपवाद व्युत्पन्न केले जातात. जेव्हा असे होते, तेव्हा मेमरीमध्ये अपवाद ऑब्जेक्ट तयार केला जातो, प्रोग्रामच्या मुख्य प्रवाहात व्यत्यय येतो आणि JVM चा अपवाद हँडलर अपवाद हाताळण्याचा प्रयत्न करतो.

अपवाद हाताळणी

Java मध्ये, आम्ही कोड ब्लॉक्स तयार करतो जिथे आम्हाला try{}catch , try{}catch{}finally , आणि try{}finally{} constructs वापरून अपवाद हाताळणीची आवश्यकता आहे . जेव्हा अपवाद ट्राय ब्लॉकमध्ये टाकला जातो, तेव्हा 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...
-----------------

शेवटी कोणत्याही प्रवाहांना बंद करण्यासाठी आणि ट्राय ब्लॉकमध्ये उघडलेले / वाटप केलेले कोणतेही संसाधन मुक्त करण्यासाठी वापरले जाते . तथापि, प्रोग्राम लिहिताना, सर्व संसाधने बंद केल्याचा मागोवा ठेवणे नेहमीच शक्य नसते. आमचे जीवन सोपे करण्यासाठी, Java चे डेव्हलपर ट्राय-विथ-रिसोसेस कंस्ट्रक्ट ऑफर करतात, जे ट्राय ब्लॉकमध्ये उघडलेले कोणतेही संसाधन आपोआप बंद करते . आमचे पहिले उदाहरण संसाधनांसह प्रयत्न करून पुन्हा लिहिले जाऊ शकते :

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 मध्ये सादर केलेल्या Java क्षमतांबद्दल धन्यवाद, आम्ही विषम अपवाद पकडणे एका ब्लॉकमध्ये एकत्र करू शकतो, कोड अधिक संक्षिप्त आणि वाचनीय बनवू शकतो. उदाहरण:

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;
}

तळ ओळ

Java मधील अपवाद वापरणे तुम्हाला "बॅकअप मार्ग" तयार करून तुमचे प्रोग्राम अधिक मजबूत बनवू देते, अपवाद हँडलिंग कोडपासून मुख्य कोड वेगळे करण्यासाठी कॅच ब्लॉक्सचा वापर करू शकतात आणि अपवाद हाताळणीची जबाबदारी जो कोणी तुमची पद्धत वापरतो त्याच्याकडे हलवण्यासाठी थ्रो वापरा.