समस्या को मॉड्यूल और क्लास में तोड़ना
मॉड्यूल प्रोग्राम का एक अलग हिस्सा है जिसका एक ही काम है। समस्या तोड़ने के लिए:
- लिखिए कि पूरा प्रोग्राम क्या करेगा।
- समस्या की मुख्य चीज़ें (संज्ञा) लिखिए: सदस्य, किताबें, उधारी। हर एक क्लास बन सकती है, जिसमें उसका डेटा और मेथड हों।
- मुख्य काम (क्रिया) लिखिए: जोड़ना, खोजना, देना, लौटाना। हर एक मेथड या फ़ंक्शन बनता है।
- स्ट्रक्चर चार्ट (पेड़ जैसा चित्र) बनाइए: ऊपर प्रोग्राम, नीचे मॉड्यूल, उनके नीचे उप-प्रोग्राम।
दो जाँच: उच्च संसंजन (मॉड्यूल की हर चीज़ एक ही काम से जुड़ी) और कम युग्मन (मॉड्यूल एक-दूसरे पर कम से कम निर्भर)।
उप-प्रोग्राम डिज़ाइन में फ़ंक्शनल अपघटन
फ़ंक्शनल अपघटन ऊपर से नीचे (top-down) डिज़ाइन है: काम को छोटे उप-कामों में तोड़िए, फिर उन्हें भी, जब तक हर टुकड़ा एक छोटा उप-प्रोग्राम (फ़ंक्शन, प्रोसीजर या मेथड) न बन जाए।
issueBook(memberId, bookId) ├─ checkMember(memberId) ├─ checkAvailable(bookId) ├─ recordLoan(memberId, bookId, dueDate) └─ printSlip()
हर उप-प्रोग्राम के साफ़ पैरामीटर (इनपुट) और रिटर्न मान (आउटपुट) होते हैं। अच्छे नियम: एक फ़ंक्शन, एक काम; नाम क्रिया जैसा; आमतौर पर एक स्क्रीन से छोटा; ग्लोबल चर का छिपा उपयोग नहीं।
प्रोग्रामर स्टब (खाली जगह-भराऊ फ़ंक्शन) से ऊपर का हिस्सा पहले जाँच लेते हैं।
प्रोग्राम डिज़ाइन में डेटा एनकैप्सुलेशन
एनकैप्सुलेशन यानी डेटा और उस पर काम करने वाला कोड साथ रखना, और डेटा को बाहर से छिपाना। ज़्यादातर भाषाओं में फ़ील्ड private और मेथड public (यही इंटरफ़ेस) होते हैं।
class Account {
private double balance;
public void deposit(double x) { if (x > 0) balance += x; }
public double getBalance() { return balance; }
}बाहर का कोई कोड balance को −500 नहीं कर सकता, क्योंकि अंदर जाने का रास्ता सिर्फ़ deposit() है, जो मान जाँचता है। फ़ायदे: डेटा सही रहता है, अंदर का तरीका बाद में बदला जा सकता है, और हर मॉड्यूल समझना आसान है।
प्रोग्राम डिज़ाइन में पुन: उपयोग
पुन: उपयोग यानी मॉड्यूल एक बार लिखो, कई जगह इस्तेमाल करो। कोड दोबारा इस्तेमाल लायक बनाने के तरीके:
- तय मान की जगह पैरामीटर लीजिए (
sort(list)हर सूची के लिए)। - मॉड्यूल सामान्य और स्वतंत्र रखिए (कम युग्मन)।
- साझा कोड लाइब्रेरी या पैकेज में रखिए; क्लास के लिए इनहेरिटेंस या कंपोज़िशन।
- इंटरफ़ेस लिखकर समझाइए: क्या अंदर जाता है, क्या बाहर आता है।
पुन: उपयोग से समय बचता है, बग घटते हैं (जाँचा हुआ कोड फिर से), और प्रोग्राम एक जैसे रहते हैं।
करके देखें
बिना कंप्यूटर: पन्ने के ऊपर "नाश्ता बनाना" लिखिए। इसे 3 मॉड्यूल में, फिर हर एक को 2–3 चरणों में तोड़िए। जो चरण "दोपहर का खाना" में भी काम आए, उस पर गोला लगाइए।
3D में: तोड़ें दो बार दबाइए और टुकड़े गिनिए (1 → 3 → 6)। फिर छिपाएँ और पुन: उपयोग दबाइए।
मुख्य सूत्र और परिभाषाएँ
- मॉड्यूल: एक काम वाला अलग हिस्सा
- फ़ंक्शनल अपघटन: काम → उप-काम → उप-प्रोग्राम (ऊपर से नीचे)
- एनकैप्सुलेशन: private डेटा + public मेथड (इंटरफ़ेस)
- अच्छा डिज़ाइन: उच्च संसंजन, कम युग्मन
- पुन: उपयोग: एक बार लिखो, कई बार इस्तेमाल करो
- स्ट्रक्चर चार्ट: मॉड्यूल और उप-प्रोग्राम का पेड़
हल किए गए उदाहरण
1. स्कूल रिपोर्ट-कार्ड प्रोग्राम को मॉड्यूल में तोड़िए।
मॉड्यूल: छात्र (नाम, ID), अंक (अंक भरना और जाँचना), गणना (कुल, औसत, ग्रेड), रिपोर्ट (छापना)। हर एक का एक काम, इसलिए हर एक अलग से जाँचा जा सकता है।
2. "छात्र का ग्रेड निकालना" को उप-प्रोग्राम में तोड़िए।
readMarks(id) → total(marks) → average(total, count) → gradeFor(average) → ग्रेड लौटाओ। हर फ़ंक्शन इनपुट लेकर एक परिणाम लौटाता है।
3. BankAccount क्लास में balance private क्यों हो?
ताकि कोई और कोड उसे गलत मान न दे सके। हर बदलाव deposit() और withdraw() से होता है, जो रकम जाँचते हैं।
4. एक फ़ंक्शन area = 3.14 × 5 × 5 निकालता है। इसे दोबारा इस्तेमाल लायक कैसे बनाएँ?
पैरामीटर जोड़िए: area(r) = 3.14159 × r × r। अब हर त्रिज्या के लिए काम करेगा और इसे गणित मॉड्यूल में रख सकते हैं।
5. मॉड्यूल A, B के चर सीधे पढ़ता है और B, A के। क्या गड़बड़ है?
युग्मन ज़्यादा है: एक बदला तो दूसरा टूटेगा। हल: चर private कीजिए और पैरामीटर व रिटर्न मान से डेटा भेजिए।
आम गलतियाँ
- सब कुछ करने वाला एक बहुत बड़ा फ़ंक्शन बनाना। उसे तोड़िए ताकि हर फ़ंक्शन का एक काम हो।
- मॉड्यूल के बीच डेटा बाँटने के लिए ग्लोबल चर इस्तेमाल करना। पैरामीटर और रिटर्न मान दीजिए।
- सारे फ़ील्ड public बना देना। इससे एनकैप्सुलेशन टूटता है।
- बहुत ज़्यादा तोड़ देना: दर्जनों एक-लाइन फ़ंक्शन जिनके नाम अस्पष्ट हों। जब हर टुकड़ा साफ़ और जाँचने लायक हो, रुक जाइए।