अपवाद: चेक किया गया, अनचेक किया गया और कस्टम

नमस्ते! पिछले पाठ में, हम जावा भाषा में अपवादों से परिचित हुए, और उनके साथ काम करने के उदाहरण देखे। आज हम अपवादों की संरचना पर गहराई से नज़र डालेंगे, और सीखेंगे कि अपने अपवादों को कैसे लिखना है :)

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

जैसा कि हमने पहले कहा, जावा में बहुत सारे अपवाद हैं, लगभग 400! लेकिन वे सभी समूहों में विभाजित हैं, इसलिए उन्हें याद रखना काफी आसान है। यह ऐसा दिखता है: सभी अपवादों का Throwableवर्ग में एक सामान्य पूर्वज होता है। इससे दो प्रमुख समूह प्राप्त हुए हैं: अपवाद ( अपवाद ) और त्रुटियाँ ( त्रुटि )। त्रुटि - यह जावा वर्चुअल मशीन के संचालन से संबंधित एक महत्वपूर्ण रन-टाइम त्रुटि का प्रतिनिधित्व करता है। ज्यादातर मामलों में, त्रुटि को संभालने की आवश्यकता नहीं होती है, क्योंकि यह कोड में कुछ गंभीर खामियों को इंगित करता है। इनमें से सबसे प्रसिद्ध हैं StackOverflowError (यह तब होता है, उदाहरण के लिए, जब कोई विधि स्वयं को अंतहीन रूप से कॉल करती है) और OutOfMemoryError(ऐसा तब होता है जब नए ऑब्जेक्ट बनाने के लिए पर्याप्त मेमोरी नहीं होती है)। जैसा कि आप देख सकते हैं, इन स्थितियों में, आमतौर पर रन टाइम पर संभालने के लिए कुछ भी नहीं होता है: कोड केवल गलत तरीके से लिखा जाता है और उसे फिर से काम करने की आवश्यकता होती है। अपवाद - यह प्रतिनिधित्व करता है, ठीक है, एक अपवाद: एक असाधारण, अनियोजित स्थिति जो तब होती है जब कार्यक्रम चल रहा होता है। वे त्रुटि की तरह गंभीर नहीं हैं, लेकिन फिर भी उन्हें हमारे ध्यान की आवश्यकता है। सभी अपवादों को 2 प्रकारों में बांटा गया है: चेक किया गया और अनचेक किया गया । सभी चेक किए गए अपवाद Exceptionवर्ग से प्राप्त किए गए हैं। "चेक किया गया" का क्या अर्थ है? हमने पिछले पाठ में इसकी ओर संकेत किया था: "जावा संकलक इसलिए सबसे आम अपवादों और उन स्थितियों को जानता है जहां वे हो सकते हैं।" उदाहरण के लिए, यह जानता है कि यदि कोड फ़ाइल से डेटा पढ़ता है, तो फ़ाइल आसानी से मौजूद नहीं हो सकती। और ऐसी बहुत सी स्थितियाँ हैं (जिसका वह अनुमान लगा सकता है)। तदनुसार, संकलक इन संभावित अपवादों की उपस्थिति के लिए हमारे कोड की अग्रिम जांच करता है। यदि यह उन्हें मिल जाता है, तो यह कोड को तब तक संकलित नहीं करेगा जब तक कि हम उन्हें संभाल नहीं लेते या उन्हें फिर से फेंक नहीं देते। दूसरे प्रकार का अपवाद "अनियंत्रित" है। वे RuntimeExceptionवर्ग से व्युत्पन्न हैं। वे चेक किए गए अपवादों से कैसे भिन्न हैं? ऐसा लगता है कि कई अलग-अलग वर्ग भी व्युत्पन्न हुए हैंRuntimeException(जो रनटाइम अपवादों का वर्णन करता है)। अंतर यह है कि संकलक इन त्रुटियों का अनुमान नहीं लगाता है। ऐसा लगता है कि "जब कोड लिखा गया था, तो मुझे कुछ भी संदिग्ध नहीं मिला, लेकिन जब यह चल रहा था तो कुछ गलत हो गया। जाहिर है, कोड में त्रुटियां हैं!" और वाकई ये सच है. अनचेक अपवाद अक्सर प्रोग्रामर त्रुटियों का परिणाम होते हैं। और संकलक स्पष्ट रूप से हर संभव बुरी स्थिति का पूर्वाभास नहीं कर सकता है जो लोग अपने हाथों से बना सकते हैं। :) इसलिए, यह जाँच नहीं करता है कि हमारे कोड में ऐसे अपवादों को नियंत्रित किया जाता है या नहीं। आप पहले ही कई अनियंत्रित अपवादों का सामना कर चुके हैं:

• अंकगणितीय अपवाद तब होता है जब शून्य से विभाजित किया जाता है
• एक ArrayIndexOutOfBoundsException तब होती है जब आप सरणी के बाहर किसी स्थिति तक पहुँचने का प्रयास करते हैं।

बेशक, आप कल्पना कर सकते हैं कि जावा के निर्माता अनिवार्य अपवाद हैंडलिंग पेश कर सकते थे, लेकिन इस मामले में कोड बहुत जटिल होगा। किसी भी डिवीजन ऑपरेशन के लिए, क्या आपको यह जांचने के लिए ब्लॉक लिखना होगा try-catchकि क्या आप गलती से शून्य से विभाजित हो गए हैं? जब भी आप किसी ऐरे को एक्सेस करते हैं, तो आपको try-catchयह जांचने के लिए एक ब्लॉक लिखना होगा कि आपका इंडेक्स सीमा से बाहर है या नहीं। सब कुछ स्पेगेटी कोड होगा और पूरी तरह से अपठनीय होगा। यह समझ में आता है कि इस विचार को त्याग दिया गया था। नतीजतन, अनियंत्रित अपवादों को try-catchब्लॉक में संभालने या फिर से फेंकने की आवश्यकता नहीं होती है (हालांकि यह तकनीकी रूप से संभव है, जैसा कि त्रुटि के साथ होता है)।

अपना अपवाद कैसे फेंकें

बेशक, जावा के निर्माता कार्यक्रमों में उत्पन्न होने वाली हर असाधारण स्थिति का पूर्वाभास नहीं कर सकते। दुनिया में बहुत सारे कार्यक्रम हैं, और वे बहुत विविध हैं। लेकिन इसमें चिंता की कोई बात नहीं है, क्योंकि ज़रूरत पड़ने पर आप अपना खुद का अपवाद बना सकते हैं. यह करना बहुत ही आसान है। आपको बस इतना करना है कि अपनी खुद की कक्षा बनाएं। आपको सुनिश्चित होना चाहिए कि इसका नाम "अपवाद" के साथ समाप्त होता है। कंपाइलर को इसकी आवश्यकता नहीं है, लेकिन आपके कोड को पढ़ने वाले अन्य प्रोग्रामर तुरंत समझ जाएंगे कि यह एक अपवाद वर्ग है। इसके अलावा, इंगित करें कि वर्ग Exceptionवर्ग से विरासत में मिला है (संकलक को इसकी आवश्यकता है)। उदाहरण के लिए, मान लीजिए कि हमारे पास एक Dogवर्ग है। हम कुत्ते को टहला सकते हैंwalk()तरीका। लेकिन ऐसा करने से पहले, हमें यह जांचना होगा कि हमारे पालतू जानवर ने कॉलर, पट्टा और थूथन पहन रखा है या नहीं। यदि इनमें से कोई भी गियर गायब है, तो हम अपना अपवाद फेंक देते हैं: DogIsNotReadyException । इसका कोड ऐसा दिखता है:

public class DogIsNotReadyException extends Exception {

   public DogIsNotReadyException(String message) {
       super(message);
   }
}

यह इंगित करने के लिए कि वर्ग एक अपवाद है, आपको वर्ग के नाम के बाद " एक्सटेंड एक्सेप्शन " लिखना होगा (इसका अर्थ है "कक्षा अपवाद वर्ग से ली गई है")। कंस्ट्रक्टर में, हम केवल Exceptionक्लास कंस्ट्रक्टर को स्ट्रिंग संदेश के साथ कहते हैं (यदि अपवाद होता है, तो हम संदेश, त्रुटि का विवरण, उपयोगकर्ता को दिखाएंगे)। हमारे क्लास कोड में यह इस तरह दिखता है:

public class Dog {

   String name;
   boolean isCollarPutOn;
   boolean isLeashPutOn;
   boolean isMuzzlePutOn;


   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

   }

   public void putCollar() {

       System.out.println("The collar is on!");
       this.isCollarPutOn = true;
   }

   public void putLeash() {

       System.out.println("The leash is on!");
       this.isLeashPutOn = true;
   }

   public void putMuzzle() {
       System.out.println("The muzzle is on!");
       this.isMuzzlePutOn = true;
   }

   public void walk() throws DogIsNotReadyException {

   System.out.println("We're getting ready for a walk!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("Hooray, let's go for a walk! " + name + " is very happy!");
   } else {
       throw new DogIsNotReadyException(name + " is not ready for a walk! Check the gear!");
   }
 }

}

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

public static void main(String[] args) {

   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();// Unhandled exception: DogIsNotReadyException
}

यह संकलित नहीं होगा। अपवाद संभाला नहीं है! try-catchअपवाद को संभालने के लिए हम अपने कोड को ब्लॉक में लपेटते हैं :

public static void main(String[] args) {

   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   try {
       dog.walk();
   } catch (DogIsNotReadyException e) {
       System.out.println(e.getMessage());
       System.out.println("Checking the gear! Is the collar on? " + dog.isCollarPutOn + "\r\n Is the leash on? "
       + dog.isLeashPutOn + "\r\n Is the muzzle on? " + dog.isMuzzlePutOn);
   }
}

अब कंसोल आउटपुट देखें: कॉलर चालू है! थूथन चालू है! हम टहलने के लिए तैयार हो रहे हैं! बडी टहलने के लिए तैयार नहीं है! गियर की जाँच करें! गियर की जाँच! क्या कॉलर चालू है? सच क्या पट्टा चालू है? क्या थूथन चालू है? सच देखें कि कंसोल आउटपुट कितना अधिक जानकारीपूर्ण था! हम कार्यक्रम में उठाए गए हर कदम को देखते हैं; हम देखते हैं कि त्रुटि कहां हुई, और हम तुरंत यह भी देख सकते हैं कि हमारे कुत्ते में क्या कमी है। :) और इस तरह आप अपने स्वयं के अपवाद बनाते हैं। जैसा कि आप देख सकते हैं, इसमें कुछ भी जटिल नहीं है। और भले ही जावा के रचनाकारों ने खराब सुसज्जित कुत्तों के लिए भाषा में एक विशेष अपवाद शामिल करने की जहमत नहीं उठाई, हमने उनकी निगरानी को ठीक कर दिया है। :)