java - फ़ंक्शन को कॉल करते समय "अपवाद फेंकना" क्यों आवश्यक है?




exception-handling unhandled-exception (4)

जावा की आवश्यकता है कि आप सभी अपवादों को संभाल लें या घोषित करें। यदि आप कोशिश / पकड़ ब्लॉक का उपयोग करके अपवाद का संचालन नहीं कर रहे हैं तो इसे विधि के हस्ताक्षर में घोषित किया जाना चाहिए।

उदाहरण के लिए:

class throwseg1 {
    void show() throws Exception {
        throw new Exception();
    }
}

के रूप में लिखा जाना चाहिए:

class throwseg1 {
    void show() {
        try {
            throw new Exception();
        } catch(Exception e) {
            // code to handle the exception
        }
    }
}

इस तरह आप विधि घोषणा में "थ्रो अपवाद" घोषणा से छुटकारा पा सकते हैं।

class throwseg1
{
    void show() throws Exception
    {
        throw new Exception("my.own.Exception");
    }

    void show2() throws Exception  // Why throws is necessary here ?
    {
        show();
    }

    void show3() throws Exception  // Why throws is necessary here ?
    {
        show2();
    }

    public static void main(String s[]) throws Exception  // Why throws is necessary here ?
    {
        throwseg1 o1 = new throwseg1();
        o1.show3();
    }
}

क्यों संकलक रिपोर्ट करता है कि विधियों show2() , show3() , और main() है

अपरिवर्तित अपवाद अपवाद जिसे पकड़ा जाना चाहिए या फेंक दिया जाना चाहिए

जब मैं इन विधियों से throws Exception हूं?


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

जावा में, आप Throwable क्लास को Throwable कुछ भी फेंक सकते हैं। हालांकि, आपको सभी वर्गों के लिए throws खंड निर्दिष्ट करने की आवश्यकता नहीं है। विशेष रूप से, कक्षाएं जो या तो Error या RuntimeException या इन दोनों के उप-वर्ग हैं। आपके मामले में Exception Error या RuntimeException का उप-वर्ग नहीं है। इसलिए, यह एक चेक अपवाद है और throws खंड में निर्दिष्ट होना चाहिए, अगर आप उस विशेष अपवाद को संभाल नहीं पाते हैं। यही कारण है कि आपको throws आवश्यकता है।

जावा ट्यूटोरियल से :

एक अपवाद एक घटना है, जो किसी प्रोग्राम के निष्पादन के दौरान होता है, जो प्रोग्राम के निर्देशों के सामान्य प्रवाह को बाधित करता है।

अब, जैसा कि आप जानते हैं अपवादों को दो में वर्गीकृत किया गया है: चेक किया गया और अनचेक किया गया। इन वर्गीकरण क्यों?

जांच की गई अपवाद: उनका उपयोग उन समस्याओं का प्रतिनिधित्व करने के लिए किया जाता है जिन्हें प्रोग्राम के निष्पादन के दौरान पुनर्प्राप्त किया जा सकता है। वे आमतौर पर प्रोग्रामर की गलती नहीं होते हैं। उदाहरण के लिए, उपयोगकर्ता द्वारा निर्दिष्ट फ़ाइल पठनीय नहीं है, या कोई नेटवर्क कनेक्शन उपलब्ध नहीं है, आदि, इन सभी मामलों में, हमारे प्रोग्राम को बाहर निकलने की आवश्यकता नहीं है, इसके बजाय यह उपयोगकर्ता को सतर्क करने जैसी कार्रवाई कर सकता है, या फ़ॉलबैक में जा सकता है तंत्र (जैसे नेटवर्क उपलब्ध नहीं होने पर ऑफ़लाइन काम करना) आदि।

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

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

  • त्रुटियां: त्रुटियां ऐसी स्थितियां होती हैं जिनमें से आमतौर पर प्रोग्राम पुनर्प्राप्त नहीं हो सकता है। उदाहरण के लिए, यदि एक स्टैक Error होती है, तो हमारा प्रोग्राम अधिक नहीं कर सकता है, जैसे प्रोग्राम के फ़ंक्शन कॉलिंग स्टैक के आकार को बढ़ाएं। या यदि OutOfMemoryError होती है, तो हम अपने कार्यक्रम में उपलब्ध रैम की मात्रा बढ़ाने के लिए बहुत कुछ नहीं कर सकते हैं। ऐसे मामलों में, कार्यक्रम से बाहर निकलना बेहतर है। यही कारण है कि वे अनचेक किए गए हैं।

विस्तृत जानकारी के लिए देखें:


throws Exception घोषणा उन तरीकों का ट्रैक रखने का एक स्वचालित तरीका है जो अनुमानित लेकिन अपरिहार्य कारणों के लिए अपवाद फेंक सकते हैं। घोषणा आमतौर पर प्रकार या अपवादों के प्रकारों के बारे में विशिष्ट होती है जिन्हें फेंक दिया जा सकता है जैसे throws IOException throws IOException, MyException या throws IOException, MyException

हम सभी अंततः कोड लिखते हैं या करेंगे जो अप्रत्याशित रूप से बंद हो जाता है और कुछ ऐसा होने के कारण अपवाद की रिपोर्ट करता है जिसे हमने प्रोग्राम चलाने से पहले अनुमानित नहीं किया था, जैसे कि शून्य से विभाजित या सीमा से बाहर सूचकांक। चूंकि विधि द्वारा त्रुटियों की अपेक्षा नहीं की गई थी, इसलिए उन्हें "पकड़ा" नहीं जा सका और कोशिश करने वाले क्लॉज के साथ संभाला जा सकता था। विधि के किसी भी unsuspecting उपयोगकर्ताओं को भी इस संभावना के बारे में पता नहीं होगा और उनके कार्यक्रम भी बंद हो जाएगा।

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

हालांकि जावा में अपवाद घोषित करने की क्षमता है, फिर भी आप अनचाहे और अविकसित अपवादों के साथ एक नई विधि लिख सकते हैं, और जावा इसे संकलित करेगा और आप इसे चला सकते हैं और सर्वश्रेष्ठ के लिए आशा कर सकते हैं। जावा आपको ऐसा करने की अनुमति नहीं देगा यदि यह ऐसी विधि का उपयोग करता है जिसे फेंकने वाले अपवाद के रूप में घोषित किया गया है, जब तक कि आप या तो अपनी विधि में घोषित अपवादों को संभाल न लें या अपनी विधि को फेंकने के रूप में घोषित न करें अपवाद (ओं) या यदि कई अपवाद हैं, तो आप कुछ को संभाल सकते हैं और बाकी को फेंक सकते हैं।

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

इस प्रकार के समाधान के बारे में अच्छी बात यह है कि जब संकलक रिपोर्ट करता है Error: Unhandled exception type java.io.IOException यह अपवाद को फेंकने के लिए घोषित विधि की फ़ाइल और लाइन संख्या देता है। इसके बाद आप बस हिरण पास करना चुन सकते हैं और अपनी विधि को "IOException फेंकता है" घोषित कर सकते हैं। यह मुख्य विधि तक सभी तरह से किया जा सकता है, जहां यह प्रोग्राम को रोकने और उपयोगकर्ता के अपवाद की रिपोर्ट करने का कारण बनता है। हालांकि, अपवाद को पकड़ना और इसके साथ सौदा करना बेहतर होता है जैसे कि उपयोगकर्ता को समझाया गया है कि यह क्या हुआ है और इसे कैसे ठीक किया जाए। जब कोई विधि अपवाद को पकड़ती है और संभालती है, तो इसे अब अपवाद घोषित नहीं करना पड़ता है। बकवास बोलने के लिए वहां रुक जाता है।


package javaexception;


public class JavaException {
   void show() throws Exception
    {
        throw new Exception("my.own.Exception");
    }

void show2() throws Exception  // Why throws is necessary here ?
{
    show();
}

void show3() throws Exception  // Why throws is necessary here ?
{
    show2();
}
public static void main(String[] args) {

   JavaException a = new JavaException();

   try{
   a.show3();
   }catch(Exception e){
       System.out.println(e.getMessage());
   }
}

आपके कार्यक्रम में केवल छोटे बदलाव। मुख्य मुद्दे के बारे में कई लोगों द्वारा गलत समझा जा रहा है, जब भी आप अपवाद फेंकते हैं तो आपको इसे संभालने की आवश्यकता होती है, एक ही स्थान पर आवश्यक नहीं है (आपके कार्यक्रम में उदा। शो 1,2,3 विधि) लेकिन आपको पहले कॉलर विधि पर अवश्य ही होना चाहिए 'मुख्य' के अंदर। एक शब्द में, 'फेंक' होता है, वहां 'पकड़ / प्रयास' होना चाहिए, भले ही एक ही विधि न हो, जहां अपवाद होता है।





checked-exceptions