एक मूर्खतापूर्ण प्रश्न। कोड दिया:
public static int sum(String a, String b) /* throws? WHAT? */ {
int x = Integer.parseInt(a); // throws NumberFormatException
int y = Integer.parseInt(b); // throws NumberFormatException
return x + y;
}
क्या आप बता सकते हैं कि यह जावा अच्छा है या नहीं? मैं जो बात कर रहा हूं, NumberFormatException
वह अनियंत्रित अपवाद है। आपको इसे हस्ताक्षर के भाग के रूप में निर्दिष्ट करने की आवश्यकता नहीं हैsum()
। इसके अलावा, जहां तक मैं समझता हूं, अनियंत्रित अपवादों का विचार केवल यह संकेत देना है कि प्रोग्राम का कार्यान्वयन गलत है, और इससे भी अधिक, अनियंत्रित अपवादों को पकड़ना एक बुरा विचार है, क्योंकि यह रनटाइम पर खराब प्रोग्राम को ठीक करने जैसा है ।
क्या कोई स्पष्ट करेगा कि क्या:
- मुझे
NumberFormatException
विधि के हस्ताक्षर के एक भाग के रूप में निर्दिष्ट करना चाहिए । - मुझे अपने स्वयं के चेक किए गए अपवाद को परिभाषित करना चाहिए (
BadDataException
),NumberFormatException
विधि के अंदर संभालें और इसे फिर से फेंक देंBadDataException
। - मुझे अपने स्वयं के चेक किए गए अपवाद को परिभाषित करना चाहिए (
BadDataException
), दोनों स्ट्रिंग को नियमित अभिव्यक्तियों की तरह सत्यापित करें औरBadDataException
अगर यह मेल नहीं खाता है तो मुझे फेंक दें । - आपका विचार?
अपडेट :
कल्पना कीजिए, यह एक ओपन-सोर्स फ्रेमवर्क नहीं है, जिसे आपको किसी कारण से उपयोग करना चाहिए। आप विधि के हस्ताक्षर को देखते हैं और सोचते हैं - "ठीक है, यह कभी नहीं फेंकता है"। फिर, किसी दिन, आपको एक अपवाद मिला। क्या यह सामान्य है?
अपडेट 2 :
कुछ टिप्पणियां हैं जो कहती हैं कि मेरा sum(String, String)
डिज़ाइन ख़राब है। मैं बिल्कुल सहमत हूं, लेकिन उन लोगों के लिए जो मानते हैं कि मूल समस्या कभी भी प्रकट नहीं होगी यदि हमारे पास अच्छा डिजाइन था, तो यहां एक अतिरिक्त प्रश्न है:
समस्या की परिभाषा इस प्रकार है: आपके पास एक डेटा स्रोत है जहाँ संख्याएँ String
s के रूप में संग्रहीत हैं । यह स्रोत XML फ़ाइल, वेब पेज, डेस्कटॉप विंडो 2 एडिट बॉक्स के साथ हो सकता है, जो भी हो।
आपका लक्ष्य तर्क को लागू करना है जो इन 2 String
एस को लेता है , उन्हें एस में कनवर्ट int
करता है और संदेश बॉक्स को यह कहते हुए प्रदर्शित करता है कि "योग xxx है"।
इससे कोई फर्क नहीं पड़ता कि आप इसे डिजाइन / कार्यान्वित करने के लिए किस दृष्टिकोण का उपयोग करते हैं, आपके पास आंतरिक कार्यक्षमता के ये 2 बिंदु होंगे :
- वह स्थान जहाँ आप रूपांतरित
String
होते हैंint
- ऐसी जगह जहां आप 2
int
एस जोड़ते हैं
मेरी मूल पोस्ट का प्राथमिक प्रश्न है:
Integer.parseInt()
सही स्ट्रिंग को पारित करने की अपेक्षा करता है । जब भी आप एक खराब स्ट्रिंग पास करते हैं , तो इसका मतलब है कि आपका प्रोग्राम गलत है (" आपका उपयोगकर्ता एक बेवकूफ है")। आपको कोड का टुकड़ा लागू करने की आवश्यकता है जहां एक ओर आपके पास Integer.parseInt () MUST शब्दार्थ के साथ और दूसरी ओर आपको इनपुट गलत होने पर मामलों के साथ ठीक होने की आवश्यकता है - SHOULD शब्दार्थ ।
इसलिए, संक्षेप में: यदि मैं केवल MUST पुस्तकालयों को लागू करूं तो मैं SHOULD शब्दार्थ को कैसे लागू कर सकता हूं ।