जावा में, किन अपवादों की जाँच की जाती है? [बन्द है]


14

जावा के चेक किए गए अपवादों ने पिछले कुछ वर्षों में कुछ बुरे प्रेस दिए हैं। एक बताने वाला संकेत यह है कि यह वस्तुतः दुनिया की एकमात्र भाषा है, जिसमें उनके पास (ग्रूवी और स्काला जैसी अन्य JVM भाषाएँ भी नहीं हैं)। स्प्रिंग और हाइबरनेट जैसी प्रमुख जावा लाइब्रेरी भी इनका उपयोग नहीं करती हैं।

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

क्या कोई अन्य उपयोग हैं जो मुझे एहसास नहीं हैं?


सभी जावा कोर लाइब्रेरीज़ काफी बड़े पैमाने पर अपवादों की जाँच करती हैं।
जूनास पुलकाका

3
@ जूनो मुझे पता है, और यह एक दर्द है!
ब्रैड कपिट

जवाबों:


22

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

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

मुझे चेक किए गए अपवाद पसंद हैं क्योंकि वे मुझे जल्दी से जल्दी त्रुटि सुधार के बारे में सोचने के लिए मजबूर करके मेरे कोड को और अधिक मजबूत बनाते हैं।

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

यह हो सकता है कि लापता फ़ाइल एक घातक चीज है और इस कार्यक्रम को आग की लपटों में दुर्घटना का कारण बनना चाहिए, लेकिन तब आप उस निर्णय के साथ

} catch (FileNotFoundException e) {
  throw new RuntimeException("Important file not present", e);
}

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

लोग कह सकते हैं कि "हम इसे केवल डिबगर में पुन: पेश करने के लिए चला सकते हैं", लेकिन मैंने पाया है कि बहुत बार उत्पादन त्रुटियों को बाद में पुन: पेश नहीं किया जा सकता है , और हम बहुत बुरा मामलों को छोड़कर उत्पादन में डिबगर्स नहीं चला सकते हैं जहां अनिवार्य रूप से आपकी नौकरी दांव पर है।

आपके स्टैक ट्रेस में अधिक जानकारी, बेहतर। चेक किए गए अपवादों से मुझे उस जानकारी को वहां और जल्दी लाने में मदद मिलती है।


EDIT: यह लाइब्रेरी डिजाइनरों के लिए भी जाता है। एक पुस्तकालय जिसका मैं दैनिक आधार पर उपयोग करता हूं, उनमें कई, कई जाँच किए गए अपवाद शामिल हैं, जिन्हें बहुत बेहतर तरीके से डिजाइन किया जा सकता था, जो इसे उपयोग करने के लिए कम थकाऊ बनाते हैं।


+1। स्प्रिंग के डिजाइनरों ने बहुत सारे हाइबरनेट अपवादों को अनियंत्रित अपवादों में अनुवाद करने का अच्छा काम किया।
फिल

FYI करें: फ्रैंक सोमरस ने इस सूत्र में उल्लेख किया है कि गलती-सहिष्णु सॉफ्टवेयर अक्सर एक ही तंत्र पर निर्भर करता है। शायद आप अपने जवाब को वसूली योग्य मामले और घातक मामले में तोड़ सकते हैं।
11'11

@rwong, क्या आप अधिक विस्तार से बता सकते हैं कि आपके मन में क्या है?

11

आपको दो अच्छे उत्तर मिले हैं, जो बताते हैं कि कौन से चेक किए गए अपवाद अभ्यास में बन गए हैं। (+1 से दोनों।) लेकिन यह जांचने के लिए भी सार्थक होगा कि वे सिद्धांत में क्या थे, क्योंकि इरादा वास्तव में सार्थक है।

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

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

data Foo a =
     Success a
   | DidNotWorkBecauseOfA
   | DidNotWorkBecauseOfB

यह प्रोग्रामर को बताता है कि फ़ंक्शन के पास सफलता के अलावा दो अतिरिक्त संभावित परिणाम हैं।


टाइप सुरक्षा के बारे में जाँच किए जा रहे अपवादों के लिए +1। मैंने उस विचार को पहले कभी नहीं सुना है, लेकिन यह इतना समझ में आता है।
Ixrec

11

IMO, जाँच किए गए अपवाद एक त्रुटिपूर्ण कार्यान्वयन हैं जो एक बहुत ही सभ्य विचार हो सकता है (पूरी तरह से अलग परिस्थितियों में - लेकिन वास्तव में वर्तमान परिस्थिति में एक अच्छा विचार नहीं है)।

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

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

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

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

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


सीधे अपवाद को संभालने के बारे में आपका पहला प्रारंभिक बयान पहले से ही गलत है; आप केवल एक थ्रो स्टेटमेंट जोड़ सकते हैं, और वह थ्रो स्टेटमेंट एक पैरेंट प्रकार का हो सकता है। इसके अलावा, अगर आपको वास्तव में नहीं लगता कि आपको इसे संभालना है तो आप इसे बदले में RuntimeException में बदल सकते हैं। आईडीई आमतौर पर दोनों कार्यों में आपकी मदद करता है।
मार्टन बोदवेस

2
@owlstead: धन्यवाद - मुझे शायद वहाँ शब्द के साथ अधिक सावधान रहना चाहिए था। यह बिंदु इतना अधिक नहीं था कि आपको वास्तव में अपवाद को पकड़ना पड़ा क्योंकि यह था कि कोड के प्रत्येक मध्यवर्ती स्तर को प्रत्येक अपवाद के बारे में पता होना चाहिए जो इसके माध्यम से प्रवाह कर सकता है। बाकी के लिए: एक उपकरण जो आपके कोड की गड़बड़ी को त्वरित और आसान बनाता है, इस तथ्य को नहीं बदलता है कि यह कोड की गड़बड़ी कर रहा है।
जेरी कॉफिन

जाँच किए गए अपवाद आकस्मिकताओं के लिए अभिप्रेत थे - असफलताओं से अलग, सफलता के अलावा अन्य पूर्वानुमानित और पुनर्प्राप्ति योग्य परिणाम - अप्रत्याशित निम्न-स्तरीय / या सिस्टम की समस्याएं। FileNotFound या JDBC कनेक्शन खोलने में त्रुटि दोनों को आकस्मिक रूप से सही माना जाता था। दुर्भाग्य से, जावा लाइब्रेरी डिजाइनरों ने कुल गलती की और सभी अन्य IO और SQL अपवादों को 'चेक' किए गए वर्ग को भी सौंपा; इन के बावजूद लगभग पूरी तरह से अप्राप्य है। literatejava.com/exception/…
थॉमस डब्ल्यू

@owlstead: चेक किए गए अपवादों को कॉल स्टैक के मध्यवर्ती परतों के माध्यम से केवल बुलबुला होना चाहिए, अगर उन्हें उन मामलों में फेंक दिया जाता है जो मध्यवर्ती कॉलिंग कोड की अपेक्षा रखते हैं । IMHO, अपवादों की जाँच एक अच्छी बात होती अगर कॉल करने वालों को या तो उन्हें पकड़ना होता या संकेत मिलता कि वे अपेक्षित थे या नहीं ; अप्रत्याशित अपवाद स्वचालित रूप से एक UnexpectedExceptionप्रकार से लिपटे होने चाहिए RuntimeException। ध्यान दें कि "फेंकता" और "उम्मीद नहीं करता है" विरोधाभासी नहीं हैं; अगर fooफेंकता है BozExceptionऔर कहता है bar, तो इसका मतलब यह नहीं है कि वह barफेंकने की उम्मीद करता है BozException
सुपरकैट

10

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


4
आसान तय throws FileNotFoundException:। हार्ड फिक्स:catch (FileNotFoundException e) { throw RuntimeException(e); }
थॉमस एडिंग

5

मुझे लगता है कि यह कहना उचित है कि जाँच किए गए अपवाद थोड़े असफल प्रयोग थे। जहां वे गलत हो गए थे कि उन्होंने लेयरिंग को तोड़ दिया था:

  • मॉड्यूल ए मॉड्यूल बी के शीर्ष पर बनाया जा सकता है, जहां
  • मॉड्यूल बी मॉड्यूल सी के शीर्ष पर बनाया जा सकता है।
  • मॉड्यूल सी एक त्रुटि की पहचान करने का तरीका जान सकता है, और
  • मॉड्यूल ए को पता चल सकता है कि त्रुटि को कैसे संभालना है।

संबंधित का अच्छा पृथक्करण टूट गया है, क्योंकि अब त्रुटियों का ज्ञान जो ए और सी तक सीमित हो सकता था, अब बी पर बिखरे रहना होगा।

विकिपीडिया पर जाँच अपवादों की एक अच्छी चर्चा है।

और ब्रूस एकेल ने इस पर एक अच्छा लेख भी लिखा है । यहाँ एक उद्धरण है:

[टी] वह अधिक यादृच्छिक नियम आपको प्रोग्रामर पर ढेर करता है, ऐसे नियम जिनका हाथ में समस्या को हल करने से कोई लेना-देना नहीं है, प्रोग्रामर का उत्पादन धीमा हो सकता है। और यह एक रैखिक कारक नहीं लगता है, लेकिन एक घातीय है

मेरा मानना ​​है कि सी ++ के मामले में, यदि सभी तरीकों में throwsविनिर्देशन खंड है, तो आपके पास कुछ अच्छे अनुकूलन हो सकते हैं। मुझे विश्वास नहीं है कि जावा के वैसे भी वे फायदे हो सकते हैं, क्योंकि RuntimeExceptionsजाँच नहीं की जाती है। एक आधुनिक जेआईटी को वैसे भी ठीक कोड का अनुकूलन करने में सक्षम होना चाहिए।

AspectJ की एक अच्छी विशेषता अपवाद सॉफ्टनिंग है: आप चेक किए गए अपवादों को अनियंत्रित अपवादों में बदल सकते हैं, विशेष रूप से लेयरिंग को बढ़ाने के लिए।

शायद यह विडंबना ही है कि जावा इस परेशानी से गुजरता है, जब वह nullइसके बजाय जांच कर सकता था , जो शायद अधिक मूल्यवान था


हाहा, उस चीज़ के बारे में कभी नहीं सोचा था कि अशक्त चीज़ के लिए एक निर्णय के रूप में जाँच नहीं किया ... लेकिन मैं अंत में समझ गया कि यह ऑब्जेक्टिव-सी में काम करने के बाद एक जन्मजात समस्या नहीं है, जो नल को बुलाया तरीकों की अनुमति देता है।
दान रोसेनस्टार्क

3
नल-जाँच एक बहुत बड़ा दर्द है - आपको हमेशा जाँच करनी पड़ती है - साथ ही यह कारण नहीं बताता है, जिसका नाम एक अपवाद है।

5

मुझे अपवादों से प्यार है।

हालाँकि, मैं लगातार उनके मिस-यूज़ से दुखी हूँ।

  1. फ्लो-हैंडलिंग के लिए उनका उपयोग न करें। आप ऐसा कोड नहीं चाहते हैं जो कुछ करने की कोशिश करता है और इसके बजाय कुछ और करने के लिए ट्रिगर के रूप में एक अपवाद का उपयोग करता है क्योंकि अपवाद ऐसी वस्तुएं हैं जिन्हें बनाने और स्मृति आदि का उपयोग करने की आवश्यकता है आदि, क्योंकि आपको कुछ लिखने के लिए परेशान नहीं किया जा सकता है। अपनी कॉल करने से पहले अगर () की तरह की जाँच करें। यह सिर्फ आलसी है और शानदार अपवाद को एक बुरा नाम देता है।

  2. उन्हें निगल मत करो। कभी। किन्हीं भी परिस्थितियों में। एक पूर्ण न्यूनतम के रूप में आप अपनी लॉग फ़ाइल में कुछ इंगित करने के लिए छड़ी करते हैं कि एक अपवाद हुआ। अपवादों को निगलने वाले कोड के माध्यम से अपना रास्ता ट्रैक करने की कोशिश करना एक बुरा सपना है। फिर से, आप शक्तिशाली अपवाद को अपमान में लाने के लिए अपवाद-निगल लें!

  3. अपने OO टोपी के साथ अपवाद का इलाज करें। सार्थक पदानुक्रम के साथ अपनी स्वयं की अपवाद वस्तुएं बनाएं। अपने व्यापार तर्क और अपने अपवादों को हाथ से हाथ में ले लें। मुझे लगता था कि अगर मैं एक सिस्टम के नए क्षेत्र पर शुरू करता हूं तो मुझे कोडिंग के आधे घंटे के भीतर उप-क्लास एक्सेप्शन की आवश्यकता होगी, इसलिए इन दिनों मैं एक्ससेप्शन क्लासेस लिखकर शुरू करता हूं।

  4. यदि आप कोड के 'चौखटे' बिट्स लिख रहे हैं, तो सुनिश्चित करें कि आपके सभी शुरुआती इंटरफेस को आपके स्वयं के नए अपवादों को फेंकने के लिए लिखा गया है, जहाँ उपयुक्त हो ... और सुनिश्चित करें कि आपके कोडर्स के कोड के स्थान के आसपास कुछ नमूना कोड हैं, जब उनका कोड क्या करना है IOException को फेंकता है, लेकिन वे जिस इंटरफ़ेस को लिख रहे हैं, वह 'ReportingApplicationException' को फेंकना चाहता है।

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


2
अच्छे निर्देशों के लिए +1। इसके अलावा, जहां उपयुक्त हो, initCauseअपवाद के साथ अपवाद का उपयोग करें या आरंभ करें जो इसका कारण बना। उदाहरण: आपके पास एक I / O उपयोगिता है जिसे लिखने में विफल होने पर आपको केवल एक अपवाद की आवश्यकता होती है। हालाँकि, कई कारण हैं कि कोई लेखन विफल हो सकता है (पहुँच प्राप्त नहीं कर सकता, लेखन त्रुटि, आदि) अपने कस्टम अपवाद को एक कारण से फेंक दें ताकि मूल समस्या निगल न जाए।
माइकल के

3
मैं असभ्य नहीं बनना चाहता, लेकिन इसके अपवादों का क्या करना है? :)
जूनो

जाँच किए गए अपवादों की अपनी पदानुक्रम लिखने के लिए फिर से लिखा जा सकता है।
Maarten Bodewes

4

जाँच किए गए अपवाद एडीए में भी हैं।

(चेतावनी, इस पोस्ट में दृढ़ता से विश्वास है कि आप टकराव पा सकते हैं।)

प्रोग्रामर उन्हें पसंद नहीं करते हैं और शिकायत करते हैं, या अपवाद निगल कोड लिखते हैं।

चेक किए गए अपवाद मौजूद हैं क्योंकि चीजें न केवल काम करने में विफल हो सकती हैं, आप विफलता मोड / प्रभाव विश्लेषण कर सकते हैं और इसे पहले से निर्धारित कर सकते हैं।

फ़ाइल रीड विफल हो सकते हैं। RPC कॉल विफल हो सकती है। नेटवर्क IO विफल हो सकता है। जब पार्स किया जाता है तो डेटा को गलत स्वरूपित किया जा सकता है।

कोड के लिए "खुश पथ" आसान है।

मुझे विश्वविद्यालय में एक व्यक्ति पता था जो महान "खुशहाल पथ" कोड लिख सकता था। किनारे के किसी भी मामले में कभी काम नहीं किया। इन दिनों वह एक ओपन सोर्स कंपनी के लिए पायथन करता है। निफ ने कहा।

यदि आप चेक किए गए अपवादों को संभालना नहीं चाहते हैं, तो आप वास्तव में क्या कह रहे हैं

While I'm writing this code, I don't want to consider obvious failure modes.

The User will just have to like the program crashing or doing weird things.

But that's okay with me because 

I'm so much more important than the people who will have to use the software

in the real, messy, error-prone world.

After all, I write the code once, you use it all day long.

इसलिए चेक किए गए अपवाद प्रोग्रामर्स को पसंद नहीं आने वाले हैं, क्योंकि इसका मतलब है कि अधिक काम करना।

बेशक, दूसरे लोग चाहते थे कि काम पूरा हो जाए।

यदि फ़ाइल सर्वर विफल / USB स्टिक मर जाता है, तो भी वे सही उत्तर चाहते थे।

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

यदि आप एक शौकिया प्रोग्रामर (पैसे के लिए प्रोग्रामिंग नहीं) हैं, तो बिना किसी जाँच किए अपवाद के साथ C # या किसी अन्य भाषा में प्रोग्राम करने के लिए स्वतंत्र महसूस करें। हेक, बीच के आदमी को काटकर लोगो में कार्यक्रम। आप कछुए के साथ फर्श पर सुंदर पैटर्न बना सकते हैं।


6
अच्छा शेख़ी तुम वहाँ मिल गए।
एडम लेअर

2
+1 "किनारे का कोई भी मामला कभी काम नहीं किया। इन दिनों वह एक ओपन सोर्स कंपनी के लिए पायथन करता है। नफ ने कहा।" क्लासिक
निमचम्पस्की

1
@palto: जावा आपको गैर-आसान पथ पर विचार करने के लिए मजबूर करता है। यही बड़ा अंतर है। सी # के लिए, आप कह सकते हैं, "अपवाद का दस्तावेजीकरण किया गया है" और अपने हाथों को धो लें। लेकिन प्रोग्रामर त्रुटि प्रवण हैं। वे चीजें भूल जाते हैं। जब मैं कोड लिखता हूं, तो मैं चाहता हूं कि 100% किसी भी दरार की याद दिलाता है एक संकलक मुझे सूचित कर सकता है।
थॉमस ईडिंग

2
@ThomasEding जावा मुझे अपवाद को संभालने के लिए मजबूर करता है जहां विधि कहा जाता है। यह बहुत दुर्लभ है कि मैं वास्तव में कॉलिंग कोड में इसके बारे में कुछ करना चाहता हूं और आमतौर पर मैं अपने आवेदन की त्रुटि हैंडलिंग परत के अपवाद को छोड़ना चाहता हूं। फिर मुझे इसे रनटाइम अपवाद में अपवाद को लपेटने के साथ उपाय करना होगा या मुझे अपना अपवाद बनाना होगा। आलसी प्रोग्रामर के पास एक तीसरा विकल्प होता है: बस इसे अनदेखा करें क्योंकि मुझे परवाह नहीं है। इस तरह से किसी को पता नहीं है कि त्रुटि हुई और सॉफ्टवेयर में वास्तव में अजीब कीड़े हैं। वह 3 एक अनियंत्रित अपवादों के साथ नहीं होता है।
palto

3
@ThomasEding ऐसा करना जो ऊपर की उन सभी चीज़ों के इंटरफ़ेस को बदल देगा, जो एप्लिकेशन के हर स्तर पर कार्यान्वयन विवरणों को अनावश्यक रूप से प्रकट करता है। आप केवल यह कर सकते हैं कि यदि अपवाद कुछ है जिसे आप से पुनर्प्राप्त करना चाहते हैं और यह इंटरफ़ेस में समझ में आता है। मैं अपने getPeople- विधि में IOException जोड़ना नहीं चाहता क्योंकि कुछ कॉन्फ़िगरेशन फ़ाइल अनुपलब्ध हो सकती है। यह सिर्फ समझ में नहीं आता है।
palto

4

जाँच किए गए अपवादों को लोगों को वहाँ स्रोत के करीब त्रुटियों को संभालने के लिए प्रोत्साहित करना चाहिए था। स्रोत से आगे, अधिक कार्यों को चलाने के बीच में समाप्त कर दिया है, और अधिक संभावना है कि सिस्टम ने एक असंगत स्थिति में प्रवेश किया है। इसके अतिरिक्त, यह अधिक संभावना है कि आप दुर्घटना से गलत अपवाद को पकड़ते हैं।

अफसोस की बात है कि लोगों ने अपवादों को नजरअंदाज किया है या बढ़ते फेंक विनिर्देशों को जोड़ा है। ये दोनों इस बात को याद करते हैं कि प्रोत्साहित करने के लिए कौन से जाँच अपवाद हैं। वे कई गेट्टर और सेटर कार्यों को कथित रूप से OO बनाने के लिए प्रक्रियात्मक कोड को बदलने की तरह हैं।

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


2
"अपवादों को अनदेखा करना" अक्सर सही होता है - कई बार अपवाद का सबसे अच्छा जवाब ऐप को दुर्घटनाग्रस्त होने देना होता है। इस दृष्टिकोण के लिए एक सैद्धांतिक आधार के लिए, बर्ट्रेंड मेयर्स ऑब्जेक्ट ओरिएंटेड सॉफ़्टवेयर कंस्ट्रक्शन पढ़ें । वह दिखाता है कि यदि अपवादों का सही तरीके से (अनुबंध के उल्लंघन के लिए) उपयोग किया जाता है, तो अनिवार्य रूप से दो सही प्रतिक्रियाएं हैं: (1) एप्लिकेशन को क्रैश होने दें या (2) उस समस्या को ठीक करें जो अपवाद का कारण बनी और प्रक्रिया को पुनरारंभ करें। विवरण के लिए मेयर पढ़ें; एक टिप्पणी में संक्षेप में प्रस्तुत करना कठिन है।
क्रेग स्टंट्ट्ज

1
@ क्रेग स्टंट्ज, अपवादों को नजरअंदाज करने का मतलब था कि मैं उन्हें निगल रहा था।
विंस्टन एवर्ट

आह, वह अलग है। मैं मानता हूं कि आपको उन्हें निगलना नहीं चाहिए।
क्रेग स्टंटज़

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

@Giorgio, बहुत सच है। हालांकि मुझे आश्चर्य है कि अगर हवाई जहाज या इसी तरह के मामले में अगर ठीक होने का सबसे अच्छा तरीका सिस्टम को रिबूट करना है।
विंस्टन इवर्ट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.