जावा परियोजनाओं में पैकेज के नामकरण के लिए आप किस रणनीति का उपयोग करते हैं और क्यों? [बन्द है]


88

मैं कुछ समय पहले इस बारे में सोचा था और यह हाल ही में पुनर्जीवित हुआ क्योंकि मेरी दुकान अपना पहला वास्तविक जावा वेब ऐप कर रही है।

एक परिचय के रूप में, मैं दो मुख्य पैकेज का नामकरण रणनीतियों को देखता हूं। (स्पष्ट होने के लिए, मैं संपूर्ण 'domain.company.project' भाग का उल्लेख नहीं कर रहा हूँ, मैं उस नीचे के पैकेज सम्मेलन के बारे में बात कर रहा हूँ।) वैसे भी, पैकेज नामकरण परंपराएँ जो मैं देख रहा हूँ वे इस प्रकार हैं:

  1. कार्यात्मक: व्यवसाय के डोमेन के अनुसार अपनी पहचान के बजाय अपने फ़ंक्शन के अनुसार अपने पैकेज का नामकरण। इसके लिए एक और शब्द 'लेयर' के अनुसार नाम दिया जा सकता है। तो, आपके पास * .ui पैकेज और * .domain पैकेज और * .orm पैकेज होगा। आपके पैकेज ऊर्ध्वाधर के बजाय क्षैतिज स्लाइस हैं।

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

  2. तार्किक: अपने पैकेजों को उनके व्यावसायिक डोमेन पहचान के अनुसार नाम देना और हर उस वर्ग को उस पैकेज में कार्यक्षमता के ऊर्ध्वाधर स्लाइस के साथ करना है।

    मैंने ऐसा पहले कभी नहीं देखा या सुना नहीं है, जैसा कि मैंने पहले उल्लेख किया है, लेकिन यह मेरे लिए एक टन का अर्थ है।

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

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

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

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

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


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

मुझे नहीं लगता कि यह एक निर्णय कॉल है। पहले परत द्वारा विभाजित, फिर कार्यक्षमता से निश्चित रूप से जाने का रास्ता है। मैं अपना जवाब अपडेट कर रहा हूं।
एलजेन्सो

@eljenso: बताएं कि ग्रहण करने वालों के लिए :) ग्रहण में, पहला विभाजन "सुविधाओं" के लिए होता है, जो तैनाती की इकाइयां हैं और कार्यक्षमता भी। "फ़ीचर" के अंदर, "प्लगइन्स" होते हैं, जो आमतौर पर परत द्वारा विभाजित होते हैं - लेकिन समान "फ़ीचर" के भीतर प्लगइन्स को हमेशा एक साथ तैनात किया जाना चाहिए। यदि आपके पास केवल एकल परिनियोजन इकाई है, तो पहले लेयर द्वारा विभाजित करना और उसके बाद ही कार्यक्षमता के आधार पर यह समझ में आता है। कई परिनियोजन इकाइयों के साथ, आप केवल प्रस्तुति परत को तैनात नहीं करना चाहते हैं - आप अतिरिक्त कार्यशीलता चाहते हैं।
पीटर 6

मेरे पास एक आवेदन की व्यावसायिक परत से संबंधित एक विशिष्ट प्रश्न है, नामकरण सम्मेलन क्या होना चाहिए?
Bionix1441

जवाबों:


32

पैकेज डिजाइन के लिए, मैं पहले परत से विभाजित करता हूं, फिर कुछ अन्य कार्यक्षमता के द्वारा।

कुछ अतिरिक्त नियम हैं:

  1. परतों को सबसे सामान्य (नीचे) से सबसे विशिष्ट (शीर्ष) तक ढेर किया जाता है
  2. प्रत्येक परत में एक सार्वजनिक इंटरफ़ेस (अमूर्तता) है
  3. एक परत केवल दूसरी परत के सार्वजनिक इंटरफेस पर निर्भर कर सकती है (एनकैप्सुलेशन)
  4. एक परत केवल अधिक सामान्य परतों पर निर्भर कर सकती है (ऊपर से नीचे तक निर्भरता)
  5. एक परत अधिमानतः इसके नीचे की परत पर निर्भर करती है

इसलिए, उदाहरण के लिए एक वेब एप्लिकेशन के लिए, आप अपने लेयर टियर में (ऊपर से नीचे तक) निम्न लेयर रख सकते हैं:

  • प्रस्तुति परत: UI को क्लाइंट टीयर में दिखाया जाएगा
  • आवेदन परत: इसमें तर्क है जो एक अनुप्रयोग के लिए विशिष्ट है, स्टेटफुल
  • सेवा की परत: डोमेन द्वारा समूह कार्यक्षमता, स्टेटलेस
  • एकीकरण परत: बैकएंड टियर (db, jms, ईमेल, ...) तक पहुँच प्रदान करता है

परिणामस्वरूप पैकेज लेआउट के लिए, ये कुछ अतिरिक्त नियम हैं:

  • हर पैकेज के नाम की जड़ है <prefix.company>.<appname>.<layer>
  • एक परत का इंटरफ़ेस आगे कार्यक्षमता से विभाजित है: <root>.<logic>
  • एक परत का निजी कार्यान्वयन निजी के साथ उपसर्ग है: <root>.private

यहाँ एक उदाहरण लेआउट है।

प्रस्तुति परत को दृश्य तकनीक से विभाजित किया गया है, और वैकल्पिक रूप से (समूहों के) अनुप्रयोगों द्वारा।

com.company.appname.presentation.internal
com.company.appname.presentation.springmvc.product
com.company.appname.presentation.servlet
...

एप्लिकेशन परत को उपयोग के मामलों में विभाजित किया गया है।

com.company.appname.application.lookupproduct
com.company.appname.application.internal.lookupproduct
com.company.appname.application.editclient
com.company.appname.application.internal.editclient
...

सर्विस लेयर को व्यावसायिक डोमेन में विभाजित किया जाता है, जो बैकएंड टियर में डोमेन लॉजिक से प्रभावित होता है।

com.company.appname.service.clientservice
com.company.appname.service.internal.jmsclientservice
com.company.appname.service.internal.xmlclientservice
com.company.appname.service.productservice
...

एकीकरण परत को 'प्रौद्योगिकियों' और एक्सेस ऑब्जेक्ट्स में विभाजित किया गया है।

com.company.appname.integration.jmsgateway
com.company.appname.integration.internal.mqjmsgateway
com.company.appname.integration.productdao
com.company.appname.integration.internal.dbproductdao
com.company.appname.integration.internal.mockproductdao
...

इस तरह से संकुल को अलग करने के लाभ यह है कि जटिलता का प्रबंधन करना आसान है, और यह परीक्षणशीलता और पुन: प्रयोज्यता को बढ़ाता है। हालांकि यह बहुत अधिक उपरि की तरह लगता है, मेरे अनुभव में यह वास्तव में बहुत स्वाभाविक है और इस संरचना (या इसी तरह) पर काम करने वाले हर कोई इसे कुछ दिनों में उठाता है।

मुझे क्यों लगता है कि ऊर्ध्वाधर दृष्टिकोण इतना अच्छा नहीं है?

स्तरित मॉडल में, कई अलग-अलग उच्च-स्तरीय मॉड्यूल समान निचले-स्तर के मॉड्यूल का उपयोग कर सकते हैं। उदाहरण के लिए: आप एक ही एप्लिकेशन के लिए कई दृश्य बना सकते हैं, कई एप्लिकेशन एक ही सेवा का उपयोग कर सकते हैं, कई सेवाएं एक ही गेटवे का उपयोग कर सकती हैं। यहां चाल यह है कि परतों के माध्यम से आगे बढ़ने पर, कार्यक्षमता का स्तर बदल जाता है। अधिक विशिष्ट परतों में मॉड्यूल 1-1 से अधिक सामान्य परत से मॉड्यूल पर मैप नहीं करते हैं, क्योंकि कार्यक्षमता के स्तर जो वे व्यक्त करते हैं वे 1-1 मैप नहीं करते हैं।

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


"इस तरह से पैकेजों को अलग करने के फायदे यह है कि जटिलता को प्रबंधित करना आसान है, और इससे परीक्षण और पुन: प्रयोज्यता बढ़ जाती है।" आप वास्तव में कारणों में मत जाओ कि ऐसा क्यों है।
आम डंक

1
आप कारणों में नहीं जाते हैं कि ऐसा क्यों नहीं है। लेकिन वैसे भी ... आयोजन के नियम काफी स्पष्ट और सीधे हैं, इसलिए यह जटिलता को कम करता है। यह संगठन के कारण ही अधिक परीक्षण योग्य और पुन: प्रयोज्य है। हर कोई इसे आज़मा सकता है, और बाद में हम सहमत या असहमत हो सकते हैं। मैं ऊर्ध्वाधर दृष्टिकोण के कुछ नुकसानों के बारे में संक्षेप में बता रहा हूं, इसका कारण यह है कि मुझे लगता है कि क्षैतिज दृष्टिकोण आसान है।
एलजेन्सो

8
यह लेख काफी अच्छी तरह से समझाता है कि पैकेज-बाय-लेयर के बजाय पैकेज-बाय-फ़ीचर का उपयोग करना बेहतर क्यों है ।
टॉम

@eljenso "आप कारणों में नहीं जाते हैं कि ऐसा क्यों नहीं है", सबूत के बोझ को स्थानांतरित करने की कोशिश कर रहा है? मुझे लगता है कि टॉम द्वारा पोस्ट किया गया लेख बहुत अच्छी तरह से समझाता है कि पैकेज-बाय-फीचर बेहतर क्यों है और मुझे एक कठिन समय लग रहा है "मुझे नहीं लगता कि यह एक निर्णय कॉल है। पहले परत द्वारा विभाजित, फिर कार्यक्षमता द्वारा निश्चित रूप से रास्ता है। जाने के लिए "गंभीरता से।
15

18

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

उदाहरण के लिए, डोमेन ऑब्जेक्ट्स के एक क्षैतिज स्लाइस का उपयोग विभिन्न प्रकार के फ्रंट-एंड या यहां तक ​​कि एप्लिकेशन द्वारा किया जा सकता है और वेब फ्रंट-एंड के एक क्षैतिज स्लाइस को एक साथ बदलने की संभावना है जब अंतर्निहित वेब फ्रेमवर्क को बदलना होगा। दूसरी ओर, कई पैकेजों में इन परिवर्तनों के तरंग प्रभाव की कल्पना करना आसान है यदि विभिन्न कार्यात्मक क्षेत्रों में कक्षाएं उन पैकेजों में समूहीकृत हैं।

जाहिर है, सभी प्रकार के सॉफ्टवेयर समान नहीं होते हैं और कुछ परियोजनाओं में ऊर्ध्वाधर टूटने से समझदारी (पुन: प्रयोज्य और निकटता-परिवर्तन के लक्ष्यों को प्राप्त करने के संदर्भ में) हो सकती है।


धन्यवाद, यह बहुत स्पष्ट है। जैसा कि मैंने सवाल में कहा था, मुझे ऐसा लगता है कि जितनी बार आप प्रौद्योगिकी को स्वैप करेंगे, आप कार्यक्षमता के ऊर्ध्वाधर स्लाइस के आसपास शिफ्ट होने की तुलना में बहुत कम है। क्या यह आपका अनुभव नहीं रहा है?
टिम विशेर

यह केवल प्रौद्योगिकियों के बारे में नहीं है। अपने मूल पद का बिंदु # 1 केवल तभी समझ में आता है जब ऊर्ध्वाधर स्लाइस स्वतंत्र अनुप्रयोग / सेवाएं एक दूसरे के साथ कुछ इंटरफ़ेस (SOA, यदि आप करेंगे) के माध्यम से संवाद कर रहे हैं। अधिक नीचे ...
बुउ गुयेन

अब जैसा कि आप उन सभी बारीक-बारीक ऐप / सेवा के बारे में विस्तार से जानते हैं, जिनके पास अपने स्वयं के gui / व्यवसाय / डेटा हैं, मैं शायद ही कभी सोच पाऊं कि ऊर्ध्वाधर स्लाइस में परिवर्तन, प्रौद्योगिकी, निर्भरता, नियम / वर्कफ़्लो के बारे में हो सकता है, लॉगिंग , सुरक्षा, UI शैली, को अन्य स्लाइस से पूरी तरह से अलग किया जा सकता है।
बुआ गुयेन


@BuuNguyen पैकेज डिज़ाइन सिद्धांतों का लिंक टूट गया है।
जॉनीबाई

5

आमतौर पर विभाजन के दोनों स्तर मौजूद हैं। ऊपर से, तैनाती इकाइयाँ हैं। इन्हें 'तार्किक रूप से' (आपकी शर्तों में, ग्रहण की विशेषताएँ) नाम दिया गया है। परिनियोजन इकाई के अंदर, आपके पास संकुल का कार्यात्मक विभाजन है (ईक्लिप्स प्लगइन्स सोचें)।

उदाहरण के लिए, सुविधा है com.feature, और यह के होते हैं com.feature.client, com.feature.coreऔर com.feature.uiप्लग-इन। प्लगइन्स के अंदर, मेरे पास अन्य पैकेजों के लिए बहुत कम विभाजन है, हालांकि यह भी असामान्य नहीं है।

अपडेट: Btw, Juergen Hoeller द्वारा कोड संगठन के बारे में InfoQ: http://www.infoq.com/pretations/code-organization-large-projects पर बड़ी चर्चा है । Juergen वसंत के आर्किटेक्ट में से एक है, और इस सामान के बारे में बहुत कुछ जानता है।


मैं काफी फॉलो नहीं करता। आमतौर पर आप देख सकते हैं com.apache.wicket.x जहां x या तो कार्यात्मक या तार्किक है। मैं आमतौर पर com.x नहीं देखता। मुझे लगता है कि आप कह रहे हैं कि आप com.company.project.feature.layer संरचना के साथ जाएंगे? क्या आपके पास कारण हैं?
टिम विशर

कारण यह है कि "com.company.project.feature" तैनाती की इकाई है। इस स्तर पर, कुछ सुविधाएँ वैकल्पिक हैं, और इन्हें छोड़ दिया जा सकता है (अर्थात तैनात नहीं)। हालाँकि, सुविधा के अंदर, चीजें वैकल्पिक नहीं हैं, और आप आमतौर पर उन सभी को चाहते हैं। यहाँ यह परतों द्वारा विभाजित करने के लिए अधिक समझ में आता है।
पीटर attibraný

4

अधिकांश जावा प्रोजेक्ट्स मैंने स्लाइस पर काम किया है जावा पैकेज कार्यात्मक रूप से पहले, फिर तार्किक रूप से।

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


ऐसा क्या लग सकता है? domain.company.project.function.logicalSlice?
टिम विश्वर

बहुत ज्यादा! egdcpweb.profiles, dcpweb.registration, dcpapis, dcppersistence आदि आमतौर पर बहुत अच्छी तरह से काम करता है, आपका माइलेज अलग-अलग हो सकता है। यह भी निर्भर करता है कि यदि आप डोमेन मॉडलिंग का उपयोग कर रहे हैं - यदि आपके पास कई डोमेन हैं, तो आप पहले डोमेन द्वारा विभाजित करना चाह सकते हैं।
बेन हार्डी

मैं व्यक्तिगत रूप से विपरीत, तार्किक और कार्यात्मक के लिए पसंद करता हूं। apples.rpc, apples.model और फिर banana.model, banana.store
mP।

सभी वेब सामग्री को एक साथ समूहीकृत करने की तुलना में सेब के सभी सामानों को एक साथ रखने में अधिक मूल्य है।
एम.पी.

3

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

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


आह। तो एक चीज जो क्षैतिज स्लाइस करती है, वह आपके द्वारा उपयोग किए जा रहे पुस्तकालयों में वास्तविक उन्नयन से आपको ढाल देती है। मुझे लगता है कि आप सही कह रहे हैं कि ऊर्ध्वाधर स्लाइस आपके सिस्टम के हर पैकेज पर निर्भर करती है। यह इतनी बड़ी बात क्यों है?
20

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

3

मैं व्यक्तिगत रूप से तब सामूहिक रूप से समूह बनाना पसंद करता हूं, जिसमें प्रत्येक कार्यात्मक भागीदारी के लिए एक उप-पैकेज शामिल हो।

पैकेजिंग के लक्ष्य

पैकेज एक साथ चीजों को समूहीकृत करने के बाद हैं - विचार संबंधित वर्ग एक दूसरे के करीब रहते हैं। यदि वे एक ही पैकेज में रहते हैं तो वे दृश्यता को सीमित करने के लिए पैकेज प्राइवेट का लाभ उठा सकते हैं। समस्या एक पैकेज में आपके सभी दृश्य और दृढ़ता सामग्री को एक ही पैकेज में मिश्रित करने के लिए पैदा कर सकती है। अगली समझदार चीज़ इस प्रकार है कि दृश्य, दृढ़ता, उप-पैकेज और रिफ्लेक्टर कक्षाओं का उपयोग करें। दुर्भाग्य से संरक्षित और पैकेज निजी स्कूपिंग वर्तमान पैकेज और उप पैकेज की अवधारणा का समर्थन नहीं करता है क्योंकि यह इस तरह के दृश्यता नियमों को लागू करने में सहयोगी है।

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

मेरी तार्किक पैकेजिंग संरचना का एक उदाहरण

चित्रण के प्रयोजनों के लिए दो मॉड्यूल का नाम देता है - बीमार नाम मॉड्यूल का उपयोग एक अवधारणा के रूप में करता है जो एक विशेष पेड़ की एक विशेष शाखा के तहत समूह करता है।

apple.model Apple.store banana.model केला।स्टोर

लाभ

Banana.store.BananaStore का उपयोग करने वाला ग्राहक केवल उस कार्यक्षमता के संपर्क में होता है जिसे हम उपलब्ध कराना चाहते हैं। हाइबरनेट संस्करण एक कार्यान्वयन विवरण है, जिसके लिए उन्हें जागरूक होने की आवश्यकता नहीं है और न ही इन कक्षाओं को देखना चाहिए क्योंकि वे भंडारण कार्यों में अव्यवस्था जोड़ते हैं।

अन्य तार्किक वि कार्यात्मक लाभ

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

कार्यक्षमता क्यों?

कार्यक्षमता के आधार पर चीजों को लुम्पी करने से क्या मूल्य प्राप्त होता है। ऐसे मामले में अधिकांश कक्षाएं एक-दूसरे से स्वतंत्र होती हैं, जिन्हें पैकेज के निजी तरीकों या कक्षाओं का लाभ लेने की आवश्यकता नहीं होती है। उन्हें अपने स्वयं के उप-पैकेजों में वापस लाना थोड़ा लाभ देता है लेकिन अव्यवस्था को कम करने में मदद करता है।

डेवलपर सिस्टम में परिवर्तन करता है

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


"जब डेवलपर्स [...] पैकेज ट्री के सभी क्षेत्रों की फाइलें।" आप सही हैं जब आप कहते हैं कि यह मूर्खतापूर्ण लगता है। क्योंकि यह बिल्कुल सही लेयरिंग का बिंदु है: परिवर्तन एप्लिकेशन की संपूर्ण संरचना के माध्यम से तरंग नहीं करते हैं।
22

सलाह के लिए धन्यवाद। मुझे यकीन नहीं है कि मैं आपको स्पष्ट रूप से समझ रहा हूं। मेरा मानना ​​है कि आप लॉजिकल पैकेज के लिए बहस करने की कोशिश कर रहे हैं, मैं बिल्कुल स्पष्ट नहीं हूं कि क्यों। क्या आप अपने उत्तर को थोड़ा स्पष्ट करने की कोशिश कर सकते हैं, संभवतः रिवाइडिंग? धन्यवाद!
टिम विश्वर

3

पैकेजिंग के लिए दोनों कार्यात्मक (वास्तुशिल्प) और तार्किक (सुविधा) दृष्टिकोण एक जगह है। कई उदाहरण अनुप्रयोग (पाठ्य पुस्तकों में पाए जाने वाले आदि) प्रस्तुति, व्यावसायिक सेवाओं, डेटा मैपिंग और अन्य वास्तुशिल्प परतों को अलग-अलग पैकेजों में रखने के कार्यात्मक दृष्टिकोण का पालन करते हैं। उदाहरण के अनुप्रयोगों में, प्रत्येक पैकेज में अक्सर केवल कुछ या सिर्फ एक वर्ग होता है।

यह प्रारंभिक दृष्टिकोण ठीक है क्योंकि एक आकस्मिक उदाहरण अक्सर कार्य करता है: 1) फ्रेमवर्क की वास्तुकला को वैचारिक रूप से प्रस्तुत करना, 2) एक तार्किक उद्देश्य के साथ ऐसा किया जाता है (जैसे कि एक क्लिनिक से पालतू जानवरों को जोड़ना / हटाना / अद्यतन करना / हटाना) । समस्या यह है कि कई पाठक इसे एक मानक के रूप में लेते हैं जिसकी कोई सीमा नहीं है।

"व्यवसाय" एप्लिकेशन के रूप में अधिक से अधिक सुविधाओं को शामिल करने का विस्तार होता है, कार्यात्मक दृष्टिकोण का पालन ​​करना बोझ बन जाता है। यद्यपि मुझे पता है कि आर्किटेक्चर लेयर (उदाहरण के लिए "वेब" या "यूआई" पैकेज आदि) के तहत आर्किटेक्चर लेयर पर आधारित प्रकारों के लिए कहाँ देखना है, एक एकल तार्किक विशेषता विकसित करने से कई पैकेजों के बीच आगे और पीछे कूदने की आवश्यकता होती है। यह बोझिल है, बहुत कम से कम, लेकिन इससे भी बदतर है।

चूंकि तार्किक रूप से संबंधित प्रकार एक साथ पैक नहीं किए गए हैं, इसलिए एपीआई अत्यधिक प्रचारित है; तार्किक रूप से संबंधित प्रकारों के बीच बातचीत को 'सार्वजनिक' करने के लिए मजबूर किया जाता है ताकि प्रकार एक दूसरे के साथ आयात और बातचीत कर सकें (डिफ़ॉल्ट / पैकेज दृश्यता को कम करने की क्षमता खो जाती है)।

अगर मैं एक फ्रेमवर्क लाइब्रेरी का निर्माण कर रहा हूं, तो हर तरह से मेरे पैकेज एक कार्यात्मक / वास्तु पैकेजिंग दृष्टिकोण का पालन करेंगे। मेरे एपीआई उपभोक्ता इस बात की भी सराहना कर सकते हैं कि उनके आयात विवरणों में वास्तुकला के नाम पर सहज ज्ञान युक्त पैकेज है।

इसके विपरीत, एक व्यावसायिक अनुप्रयोग का निर्माण करते समय मैं फीचर द्वारा पैकेज करूँगा। मुझे कोई भी समस्या नहीं है कि सभी एक ही " com.my.id.get " पैकेज में विजेट, विजेट, और विजेट-कंट्रोलर रखें। और फिर डिफ़ॉल्ट दृश्यता (और कम आयात विवरण के साथ-साथ अंतर-पैकेज निर्भरता होने) का लाभ उठाएं।

हालांकि, क्रॉस-ओवर मामले हैं। यदि मेरा WidgetService कई तार्किक डोमेन (सुविधाओं) द्वारा उपयोग किया जाता है, तो मैं एक " com.myorg.common.service " पैकेज बना सकता हूं । वहाँ भी एक अच्छा मौका है कि मैं इरादा फिर से प्रयोग करने योग्य सुविधाओं के पार हो सकता है और इस तरह के "के रूप में संकुल के साथ समाप्त करने के लिए के साथ कक्षाएं बना है com.myorg.common.ui.helpers। " और " com.myorg.common.util। "। मैं एक अलग परियोजना में इन सभी बाद के "सामान्य" वर्गों को आगे बढ़ा सकता हूं और उन्हें एक myorg-commons.jar निर्भरता के रूप में अपने व्यावसायिक अनुप्रयोग में शामिल कर सकता हूं।


2

यह आपकी तार्किक प्रक्रियाओं की ग्रैन्युलैरिटी पर निर्भर करता है?

यदि वे स्टैंडअलोन हैं, तो आपके पास अक्सर नए पैकेज के बजाय स्रोत नियंत्रण में उनके लिए एक नया प्रोजेक्ट होता है।

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

अंत में यह प्रतीत होता है कि यह विशेष परियोजना के लिए सबसे समझदार कैसे लगता है। मुझे लगता है कि यह विशिष्ट परियोजना स्तरित आरेख की रेखाओं के साथ पैकेज करना आसान है, लेकिन। आप तार्किक और कार्यात्मक पैकेजिंग के मिश्रण के साथ समाप्त करेंगे।

क्या जरूरत है नामांकित टैग किए गए हैं। कुछ Jython कार्यक्षमता के लिए एक XML पार्सर Jython और XML दोनों को टैग किया जा सकता है, बजाय एक या दूसरे को चुनने के।

या हो सकता है कि मैं विबलिंग कर रहा हूं।


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

जैसा कि मैंने कहा, मैं अंतर्निहित कार्यक्षमता बढ़ाने के लिए प्लगइन्स करने जा रहा हूं। एक प्लगइन अपने XML को (और अंततः DB में) पार्स करने और लिखने के साथ-साथ कार्यक्षमता प्रदान करने में सक्षम होने जा रहा है। इसलिए मेरे पास com.xx.feature.xml या com.xx.xml.feature है? भूतपूर्व लगता है।
JeeBee

2

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

मेरे लिए, क्षैतिज के बजाय ऊर्ध्वाधर नामकरण प्रणाली में बनाए रखना और कल्पना करना बहुत आसान है। अगर कंपोनेंट 1.display के पास कंपोनेंट 2.dataaccess का संदर्भ है, तो यह अधिक चेतावनी की घंटियाँ फेंकता है, अगर display.component1 में dataaccess का संदर्भ है। component2।

बेशक, दोनों द्वारा साझा किए गए घटक अपने स्वयं के पैकेज में जाते हैं।


जैसा कि मैंने आपको समझा, तब आप ऊर्ध्वाधर नामकरण सम्मेलन की वकालत करेंगे। मुझे लगता है कि यह एक * .utils पैकेज है, जब आपको कई स्लाइस में एक वर्ग की आवश्यकता होती है।
टिम विशर

2

मैं पूरी तरह से तार्किक ("बाय-फीचर") संगठन का पालन करता हूं और प्रस्तावित करता हूं! एक पैकेज को "मॉड्यूल" की अवधारणा का यथासंभव अनुसरण करना चाहिए। कार्यात्मक संगठन एक परियोजना पर एक मॉड्यूल फैला सकता है, जिसके परिणामस्वरूप कम एनकैप्सुलेशन होता है, और कार्यान्वयन विवरणों में परिवर्तन की संभावना होती है।

चलो उदाहरण के लिए एक ग्रहण प्लगइन लेते हैं: सभी विचारों या क्रियाओं को एक पैकेज में रखना एक गड़बड़ होगा। इसके बजाय, किसी सुविधा के प्रत्येक घटक को फीचर के पैकेज पर जाना चाहिए, या यदि कई हैं, तो सबपैकेज (फीचरए.हैंडलर, फीचरए.प्रदर्शन) आदि में।

बेशक, समस्या पदानुक्रमित पैकेज प्रणाली (जो अन्य जावा में है) में निहित है, जो ऑर्थोगोनल चिंताओं को संभालना असंभव या कम से कम बहुत मुश्किल है - हालांकि वे हर जगह होते हैं!


1

मैं व्यक्तिगत रूप से कार्यात्मक नामकरण के लिए जाऊंगा। संक्षिप्त कारण: यह कोड दोहराव या निर्भरता दुःस्वप्न से बचा जाता है।

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

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

मैं तार्किक नामकरण पर आपके प्रत्येक बिंदु पर अधिक सटीक प्रतिक्रिया देने का प्रयास करूंगा।

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

  2. यह मुख्य रूप से उस तरह पर निर्भर करता है जिस तरह से आप अपनी परियोजना को प्रभावित करते हैं। निश्चित रूप से, तार्किक और कार्यात्मक दृष्टिकोण ऑर्थोगोनल हैं। इसलिए यदि आप एक नामकरण सम्मेलन का उपयोग करते हैं, तो आपको कुछ आदेश रखने के लिए कक्षा एक के नाम पर दूसरे को लागू करने की आवश्यकता है, या एक नामकरण सम्मेलन से दूसरे को कुछ गहराई पर कांटा करना है।

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

  4. बड़ी, वाणिज्यिक परियोजनाओं में, बदलती प्रौद्योगिकियां अधिक बार होती हैं, जितना कि आप विश्वास करेंगे। उदाहरण के लिए, मुझे पहले से ही XML पार्सर के 3 बार, कैशिंग तकनीक के 2 बार और जियोलोकैलिसिस सॉफ्टवेयर के 2 बार बदलना पड़ा है। अच्छी बात है कि मैंने एक समर्पित पैकेज में सभी बारीकियों को छिपाया था ...


1
मुझे माफ कर दो अगर मैं गलत हूं, लेकिन यह मुझे लगता है जैसे आप एक फ्रेमवर्क विकसित करने के बारे में अधिक बात कर रहे हैं जो कि कई लोगों द्वारा उपयोग किए जाने का इरादा है। मुझे लगता है कि इस प्रकार के विकास और विकासशील अंत उपयोगकर्ता प्रणालियों के बीच नियम बदलते हैं। क्या मै गलत हु?
तिम विशर

मुझे लगता है कि कई वर्टिकल स्लाइस द्वारा उपयोग की जाने वाली सामान्य कक्षाओं के लिए, यह utilsपैकेज की तरह कुछ करने के लिए समझ में आता है । फिर, किसी भी वर्ग की जरूरत है कि बस उस पैकेज पर निर्भर कर सकते हैं।
टिम विश्वर

एक बार फिर, आकार मायने रखता है: जब कोई परियोजना काफी बड़ी हो जाती है, तो उसे कई लोगों द्वारा समर्थित होने की आवश्यकता होती है, और किसी प्रकार का विशेषज्ञता प्राप्त होगी। बातचीत को आसान बनाने और गलतियों को रोकने के लिए, परियोजना को भागों में विभाजित करना जल्दी आवश्यक हो जाता है। और बर्तन पैकेज जल्द ही बन जाएगा!
वारखान

1

यह एक दिलचस्प प्रयोग है पैकेज का उपयोग बिल्कुल नहीं (रूट पैकेज को छोड़कर)

यह सवाल तब उठता है, जब पैकेज को पेश करना कब और क्यों समझ में आता है। संभवतः, परियोजना की शुरुआत में आपने जो उत्तर दिया था, उससे उत्तर अलग होगा।

मैं मानता हूं कि आपका सवाल बिल्कुल उठता है, क्योंकि पैकेज श्रेणियों की तरह होते हैं और कभी-कभी एक या दूसरे के लिए तय करना मुश्किल होता है। कभी-कभी टैग संवाद करने के लिए अधिक सराहना करते हैं कि कई संदर्भों में एक वर्ग प्रयोग करने योग्य है।


0

विशुद्ध रूप से व्यावहारिक दृष्टिकोण से, जावा की दृश्यता निर्माण के तरीकों और गुणों तक पहुंचने के लिए एक ही पैकेज में कक्षाओं की अनुमति देती है protected और defaultदृश्यता , साथ ही साथ public। कोड की पूरी तरह से अलग परत से गैर-सार्वजनिक तरीकों का उपयोग करना निश्चित रूप से एक बड़ी कोड गंध होगा। इसलिए मैं एक ही लेयर से एक ही पैकेज में कक्षाएं लगाता हूं।

मैं अक्सर इन संरक्षित या डिफ़ॉल्ट तरीकों का उपयोग कहीं और नहीं करता - संभवतः कक्षा के लिए यूनिट परीक्षणों में छोड़कर - लेकिन जब मैं करता हूं, तो यह हमेशा एक ही परत पर एक वर्ग से होता है


क्या यह बहु-स्तरित प्रणालियों की प्रकृति के बारे में कुछ नहीं है जो हमेशा अगली परत के नीचे निर्भर रहें? उदाहरण के लिए, UI आपकी सेवाओं की परत पर निर्भर करता है जो आपके डोमेन लेयर पर निर्भर करता है, आदि पैकेजिंग स्लाइस एक साथ अत्यधिक इंटर-पैकेज निर्भरता के खिलाफ ढाल लगता है, नहीं?
20

मैं संरक्षित और डिफ़ॉल्ट विधियों का उपयोग कभी नहीं करता। 99% या तो सार्वजनिक या निजी हैं। कुछ अपवाद: (1) केवल यूनिट परीक्षणों द्वारा उपयोग की जाने वाली विधियों के लिए डिफ़ॉल्ट दृश्यता, (2) संरक्षित अमूर्त विधि जो केवल एब्सट्रैक्ट बेस क्लास से उपयोग की जाती है।
एस्को लुओटोला

1
टिम विशर, संकुल के बीच निर्भरता एक समस्या नहीं है, जब तक कि निर्भरता हमेशा एक ही दिशा में इंगित करती है और निर्भरता ग्राफ में कोई चक्र नहीं होते हैं।
एस्को लुओंटोला

0

निर्भर करता है। मेरे काम की लाइन में, हम कभी-कभी फ़ंक्शंस (डेटा एक्सेस, एनालिटिक्स) या एसेट क्लास (क्रेडिट, इक्विटी, ब्याज दर) द्वारा पैकेजों को विभाजित करते हैं। बस उस संरचना का चयन करें जो आपकी टीम के लिए सबसे सुविधाजनक है।


क्या कोई रास्ता नहीं है?
टिम विश्वर

एसेट क्लास द्वारा विभाजित करना (अधिक सामान्यतः: व्यवसाय डोमेन द्वारा) नए लोगों के लिए कोड के माध्यम से अपना रास्ता खोजना आसान बनाता है। फंक्शन द्वारा विभाजित करना एनकैप्सुलेशन के लिए अच्छा है। मेरे लिए, जावा में "पैकेज" एक्सेस C ++ में "मित्र" के समान है।
मात्रा_देव

@quant_dev मैं "असहमत होने के लिए अच्छा है" से असहमत हूं। मुझे लगता है कि आप का मतलब है कि पूर्ण विपरीत सच है। इसके अलावा, बस "सुविधा" से बाहर न निकालें। प्रत्येक के लिए एक मामला है (मेरा उत्तर देखें)।
i3ensays

-3

मेरे अनुभव से, पुन: प्रयोज्य हल करने की तुलना में अधिक समस्याएं पैदा करता है। नवीनतम और सस्ते प्रोसेसर और मेमोरी के साथ, मैं पुन: उपयोग करने के लिए कसकर एकीकृत करने के बजाय कोड का दोहराव पसंद करूंगा।


5
कोड का पुन: उपयोग हार्डवेयर की कीमत के बारे में नहीं है, बल्कि कोड रखरखाव लागत के बारे में है।
user2793390

1
सहमत हैं, लेकिन एक साधारण मॉड्यूल में कुछ तय करना पूरे कोड को प्रभावित नहीं करना चाहिए। आप किस रखरखाव लागत के बारे में बात कर रहे हैं?
रघु कस्तूरी

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