यदि नल पॉइंटर अपवाद को पकड़ना अच्छा अभ्यास नहीं है, तो अपवाद को एक अच्छा पकड़ रहा है?

Question

मैंने सुना है कि NullPointerException को पकड़ना एक बुरा अभ्यास है, और मुझे लगता है कि यह समझदारी से ऐसा है। शीर्ष पर प्रचार करने के लिए NullPointerException को देने से कुछ गलत होने का पता लगाने की अनुमति मिल जाएगी। लेकिन कई बार मैंने अपने कई दोस्तों को Exception को सीधे पकड़ लिया है ताकि उन्हें उपर्युक्त कोड में होने वाले सभी प्रकार के अपवादों के बारे में परेशान न हो। क्या यह एक अच्छा अभ्यास है? अन्य प्रकार के अपवाद क्या हैं जो अनचाहे छोड़ दिए जाते हैं? और इसके अलावा मुझे एक विशिष्ट कोड पर NullPointerException को संभालने के लिए भी समझ में आता है जहां हम अपवाद के स्रोत के बारे में सुनिश्चित हैं। तो जब अपवादों को संभाला जा सकता है और उन्हें कब संभाला नहीं जाना चाहिए? और अपवाद की संभावित सूची क्या होगी जो सबसे अच्छा छोड़ दिया गया है?

Answer 1

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

सामान्य में, पकड़ने अपवाद इन नियमों का पालन करते हैं:

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

आप आसानी से अपने कोड में एक शून्य मान की जांच कर सकते हैं, इसलिए स्पष्ट रूप से शून्य-सूचक अपवाद को पकड़ने की आवश्यकता नहीं है। NullPointerException होने के लिए यह समझ में नहीं आता है (और यह खराब अभ्यास है)। यहां तक ​​कि यदि आपके पास कुछ कोड है जो NullPointerException फेंकता है, और यह वह कोड है जिसे आप नियंत्रित नहीं करते हैं और ठीक नहीं कर सकते हैं, तो आपको इनपुट पैरामीटर निर्धारित करना चाहिए जो NullPointerException का कारण बनता है और विशेष रूप से उनके लिए परीक्षण करता है।

एक और अपवाद जो आपको नहीं पकड़ना चाहिए IllegalArgumentException है। इस अपवाद का अर्थ है कि आपने एक तर्क में पारित किया है जो समझ में नहीं आता है। इस अपवाद को पकड़ने के बजाय, आपको यह सुनिश्चित करने के लिए स्पष्ट रूप से अपने इनपुट पैरामीटर का परीक्षण करना चाहिए कि वे सचेत हैं और वे IllegalArgumentException का कारण नहीं बना सकते हैं।

Answer 2

यदि आप ऐसा करके कुछ मूल्य जोड़ सकते हैं तो आपको केवल अपवाद प्राप्त करना चाहिए। अन्यथा आपको इसे कॉलर को पास करने देना चाहिए।

NullPointerException आमतौर पर आपके कोड में एक बग का परिणाम होता है। कैच ब्लॉक में आप इसे समझदारी से कैसे ठीक कर सकते हैं?

अपवादों के बारे में परेशान नहीं होना अच्छा अभ्यास नहीं है।

Answer 3

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

Answer 4

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

Answer 5

NullPointerException को पकड़ने वाला 'कारण' एक बुरा अभ्यास माना जाता है क्योंकि कुछ गलत होने पर आपको इसे बुलबुला करने देना चाहिए! किसी भी अपवाद का कहना है कि 'बेस्ट बाएं अनचाहे' पूरी तरह से आधारित है, जो कि एक प्रकार का बुरा विचार है।

एक एनपीई प्रोग्रामिंग त्रुटि का परिणाम माना जाता है। एक कड़ाई से सही कार्यक्रम कभी एक उत्पन्न नहीं करना चाहिए। इसे पकड़े जाने का कारण खराब है, इसका मतलब यह है कि कोड का मतलब है कि कोड ने फेंक दिया है, और प्रोग्रामर ने इसे पकड़ने और इसे कवर करने का फैसला किया है, टूटी हुई कोड को ठीक करने के बजाय इसे पहले स्थान पर लेना!

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

पकड़ने java.lang.Exception विशिष्ट मामलों में वैध हो सकता है, लेकिन आम तौर पर "मैं आलसी हूँ" उनमें से एक नहीं है। :) उदाहरण के लिए यदि आप एक एपीआई को कार्यान्वित कर रहे हैं और पूरी तरह से सुनिश्चित करना चाहते हैं कि विनिर्देश में नहीं है, तो आप अपवाद को पकड़ सकते हैं और इसे परिभाषित कुछ एप्लिकेशन अपवाद में लपेट सकते हैं।

Answer 6

सामान्यतः, आपको अपवाद को पकड़ने के लिए केवल एक बार यह है कि यदि आप इसे कुछ सार्थक तरीके से संभाल सकते हैं। यदि आप नहीं कर सकते हैं तो आपको इसे शीर्ष पर बबल करना चाहिए और प्रक्रिया को समाप्त करना चाहिए। उदाहरण के लिए, क्या आप NullPointerException या I/O त्रुटि से कुछ सार्थक तरीके से पुनर्प्राप्त कर सकते हैं? मुझे नहीं लगता।

अपवाद संचालन के लिए मेरा नियम: जब तक आप उन्हें कुछ सार्थक तरीके से संभाल कर सकते हैं

• सामान्य तौर पर, अपवाद को पकड़ने नहीं है।
• प्रक्रिया/मशीन सीमाओं पर अपवादों को पकड़ें, आपके लिए उपलब्ध किसी भी संदर्भ के साथ पकड़े गए अपवाद को लॉग करें और इसे फिर से फेंक दें। यदि अपवाद एक कस्टम अपवाद है, तो आप इसे किसी प्रकार के अपवाद में लपेट सकते हैं जिसे ज्ञात प्रक्रिया के लिए ज्ञात/उपयोगी है और उसे फेंक दें।
• आप निम्न स्तर पर अपवाद भी प्राप्त कर सकते हैं, जहां आपके पास सबसे रनटाइम संदर्भ उपलब्ध है, अपवाद और संबंधित संदर्भ लॉग करें, फिर अपवाद को फिर से करें।
• जब rethrowing, throw ; बजाय throw caughtException ; का उपयोग करें। पूर्व वाक्यविन्यास का उपयोग मूल स्टैक ट्रेस को संरक्षित करता है; बाद के सिंटैक्स का उपयोग throw caughtException ; से शुरू होने वाला एक नया स्टैक ट्रेस बनाता है - आप सभी संदर्भ खो देते हैं और उस बिंदु तक ढेर कॉल करते हैं जिस पर अपवाद पकड़ा गया था।
• यदि आप चुनते हैं, तो आप उच्च स्तर पर अपवाद पकड़ सकते हैं और अपवाद की जानकारी को लॉगिंग कर सकते हैं ताकि अपवाद की समस्या को डीबग और सही करने में मदद मिल सके।

प्रवाह नियंत्रण तंत्र (यदि संभव हो) के रूप में अपवादों का उपयोग न करें। अपवाद, प्रकृति में असाधारण, अच्छी तरह से माना जाता है।इसके बजाय, पहले से, किसी भी तरीके के लिए कॉलर के अनुबंध (पूर्व शर्त) के अंत को लागू करें।

अधिक जानकारी के लिए बर्ट्रेंड मेयर्स की पुस्तक, Object Oriented Software Construction, 2nd ed. देखें।