अपवादों के प्रकार

1. अपवादों के प्रकार

सभी अपवादों को 4 प्रकारों में विभाजित किया गया है, जो वास्तव में वे वर्ग हैं जो एक दूसरे को विरासत में देते हैं।

Throwableकक्षा

सभी अपवादों के लिए आधार वर्ग वर्ग है Throwable। कक्षा Throwableमें वह कोड होता है जो वर्तमान कॉल स्टैक (वर्तमान विधि का स्टैक ट्रेस) को सरणी में लिखता है। हम थोड़ी देर बाद सीखेंगे कि स्टैक ट्रेस क्या होता है।

फेंक ऑपरेटर केवल उस वस्तु को स्वीकार कर सकता है जो कक्षा से प्राप्त होती है । Throwableऔर यद्यपि आप सैद्धांतिक रूप से कोड लिख सकते हैं throw new Throwable();, आमतौर पर कोई भी ऐसा नहीं करता है। कक्षा का मुख्य उद्देश्य Throwableसभी अपवादों के लिए एकल अभिभावक वर्ग होना है।

Errorकक्षा

अगला अपवाद वर्ग वह Errorवर्ग है, जो सीधे Throwableवर्ग को इनहेरिट करता है। गंभीर समस्या होने पर जावा मशीन Errorवर्ग (और उसके वंश) की वस्तुओं का निर्माण करती है । उदाहरण के लिए, एक हार्डवेयर खराबी, अपर्याप्त मेमोरी, आदि।

आमतौर पर, एक प्रोग्रामर के रूप में, ऐसी स्थिति में आप कुछ नहीं कर सकते हैंError जहां प्रोग्राम में ऐसी त्रुटि (जिस प्रकार के लिए a फेंका जाना चाहिए) हो: ये त्रुटियां बहुत गंभीर हैं। आप केवल इतना कर सकते हैं कि उपयोगकर्ता को सूचित करें कि प्रोग्राम क्रैश हो रहा है और/या प्रोग्राम लॉग में त्रुटि के बारे में सभी ज्ञात जानकारी लिखें।

Exceptionकक्षा

और कक्षाएं सामान्य त्रुटियों के लिए हैं जो बहुत सारी विधियों Exceptionके RuntimeExceptionसंचालन में होती हैं। प्रत्येक फेंके गए अपवाद का लक्ष्य एक ऐसे catchब्लॉक द्वारा पकड़ा जाना है जो जानता है कि इसे ठीक से कैसे संभालना है।

जब कोई विधि किसी कारण से अपना काम पूरा नहीं कर पाती है, तो उसे उपयुक्त प्रकार के अपवाद को फेंक कर तुरंत कॉलिंग विधि को सूचित करना चाहिए।

दूसरे शब्दों में, यदि एक चर के बराबर है null, तो विधि एक फेंक देगी NullPointerException। यदि गलत तर्क विधि को पारित किए गए थे, तो यह एक फेंक देगा InvalidArgumentException। यदि विधि गलती से शून्य से विभाजित हो जाती है, तो यह एक फेंक देगी ArithmeticException।

RuntimeExceptionकक्षा

RuntimeExceptionsका उपसमुच्चय हैं Exceptions। हम यह भी कह सकते हैं कि RuntimeExceptionयह सामान्य अपवादों ( ) का हल्का संस्करण है Exception— ऐसे अपवादों पर कम आवश्यकताएं और प्रतिबंध लगाए जाते हैं

Exceptionआप और RuntimeExceptionबाद में अंतर सीखेंगे ।

2. Throws: चेक किए गए अपवाद

सभी जावा अपवाद 2 श्रेणियों में आते हैं: चेक किए गए और अनचेक किए गए ।

सभी अपवाद जो इनहेरिट करते हैं RuntimeExceptionया अनियंत्रित अपवादError माने जाते हैं । अन्य सभी चेक किए गए अपवाद हैं ।

जाँचे गए और अनियंत्रित अपवादों के बीच मुख्य अंतर क्या है ?

चेक किए गए अपवादों पर अतिरिक्त आवश्यकताएं लगाई गई हैं । मोटे तौर पर, वे ये हैं:

आवश्यकता 1

यदि कोई विधि चेक किए गए अपवाद को फेंकती है , तो उसे अपने हस्ताक्षर में अपवाद के प्रकार को इंगित करना चाहिए । इस तरह, इसे कॉल करने वाली हर विधि को पता है कि इसमें "सार्थक अपवाद" हो सकता है।

कीवर्ड के बाद विधि पैरामीटर के बाद चेक किए गए अपवादों को इंगित करें ( गलती से कीवर्ड का उपयोग न करें )। ऐसा कुछ दिखता है:throwsthrow

type method (parameters) throws exception

उदाहरण:

public void calculate(int n) throws Exception
{
   if (n == 0)
      throw new Exception("n is null!");
}

public void calculate(n)
{
   if (n == 0)
      throw new RuntimeException("n is null!");
}

दाईं ओर के उदाहरण में, हमारा कोड एक अनियंत्रित अपवाद फेंकता है - कोई अतिरिक्त कार्रवाई की आवश्यकता नहीं है। बाईं ओर के उदाहरण में, विधि एक चेक किए गए अपवाद को फेंकती है, इसलिए throwsअपवाद के प्रकार के साथ-साथ कीवर्ड को विधि हस्ताक्षर में जोड़ा जाता है।

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

public void calculate(int n) throws Exception, IOException
{
   if (n == 0)
      throw new Exception("n is null!");
   if (n == 1)
      throw new IOException("n is 1");
}

आवश्यकता 2

यदि आप किसी ऐसे तरीके को कॉल करते हैं जिसने अपने हस्ताक्षर में अपवादों की जांच की है , तो आप इस तथ्य को अनदेखा नहीं कर सकते कि यह उन्हें फेंकता है।

catchआपको या तो ऐसे सभी अपवादों को हर एक के लिए ब्लॉक जोड़कर , या उन्हेंthrows अपनी विधि के लिए एक खंड में जोड़कर पकड़ना होगा।

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

उदाहरण:

कल्पना कीजिए कि हम मनुष्यों द्वारा आबाद दुनिया बनाने के लिए एक विधि लिख रहे हैं। लोगों की प्रारंभिक संख्या को एक तर्क के रूप में पारित किया जाता है। इसलिए अगर बहुत कम लोग हैं तो हमें अपवाद जोड़ने की जरूरत है।

public void createWorld(int n) throws EmptyWorldException, LonelyWorldException
{
   if (n == 0)
      throw new EmptyWorldException("There are no people!");
   if (n == 1)
      throw new LonelyWorldException ("There aren't enough people!");
   System.out.println("A wonderful world was created. Population: " + n);
}

इस विधि कॉल को 3 तरीकों से नियंत्रित किया जा सकता है:

1. कोई अपवाद न पकड़ें

यह अक्सर तब किया जाता है जब विधि को यह नहीं पता होता है कि स्थिति को ठीक से कैसे संभालना है।

public void createPopulatedWorld(int population)
throws EmptyWorldException, LonelyWorldException
{
   createWorld(population);
}

2. कुछ अपवादों को पकड़ें

हम उन त्रुटियों को संभालते हैं जिन्हें हम संभाल सकते हैं। लेकिन जिन्हें हम समझ नहीं पाते, हम उन्हें कॉलिंग मेथड तक फेंक देते हैं। ऐसा करने के लिए, हमें उनका नाम थ्रो क्लॉज में जोड़ना होगा:

public void createNonEmptyWorld(int population)
throws EmptyWorldException
{
   try
   {
      createWorld(population);
   }
   catch (LonelyWorldException e)
   {
      e.printStackTrace();
   }
}

3. सभी अपवादों को पकड़ें

यदि विधि कॉलिंग विधि के लिए अपवाद नहीं फेंकती है, तो कॉलिंग विधि हमेशा आश्वस्त रहती है कि सब कुछ अच्छी तरह से काम करता है। और यह असाधारण स्थितियों को ठीक करने के लिए कोई कार्रवाई करने में असमर्थ होगा।

public void createAnyWorld(int population)
{
   try
   {
      createWorld(population);
   }
   catch (LonelyWorldException e)
   {
      e.printStackTrace();
   }
   catch (EmptyWorldException e)
   {
      e.printStackTrace();
   }
}

3. कई अपवादों को पकड़ना

प्रोग्रामर वास्तव में डुप्लिकेट कोड से नफरत करते हैं। यहां तक ​​कि वे विकास के अनुरूप सिद्धांत के साथ आए - DRY : अपने आप को दोहराएं नहीं। लेकिन अपवादों को संभालते समय, अक्सर ऐसे मौके आते हैं जब एक tryब्लॉक के बाद catchएक ही कोड वाले कई ब्लॉक होते हैं।

catchया एक ही कोड के साथ 3 ब्लॉक और अन्य समान कोड वाले 2 catchब्लॉक हो सकते हैं । यह एक मानक स्थिति है जब आपकी परियोजना अपवादों को जिम्मेदारी से संभालती है।

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

try
{
   // Code where an exception might occur
}
catch (ExceptionType1 | ExceptionType2 | ExceptionType3 name)
{
   // Exception handling code
}

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