सामंजस्य और युग्मन के बीच अंतर


486

सामंजस्य और युग्मन के बीच अंतर क्या है?

कैसे युग्मन और सामंजस्य या तो अच्छे या खराब सॉफ्टवेयर डिजाइन को जन्म दे सकता है?

कुछ उदाहरण क्या हैं जो दोनों के बीच अंतर को रेखांकित करते हैं, और समग्र कोड गुणवत्ता पर उनका प्रभाव है?



3
मैं इस लेख की ओर इशारा करना चाहूंगा: SOLID सॉफ्टवेयर डेवलपमेंट, वन स्टेप एट ए टाइम । ग्रज़, क्रिस।
क्रि वान डर मस्त

4
यह इस विषय पर नवीनतम पोस्ट है
janisz

2
इन्हें भी देखें: stackoverflow.com/questions/39946/coupling-and-cohesion
davidpricedev

जवाबों:


702

सामंजस्य से तात्पर्य वर्ग (या मॉड्यूल) से क्या हो सकता है। कम सामंजस्य का मतलब यह होगा कि वर्ग कई प्रकार के कार्यों को करता है - यह व्यापक है, जो इसे करना चाहिए। उच्च सामंजस्य का मतलब है कि वर्ग इस पर केंद्रित है कि उसे क्या करना चाहिए, अर्थात केवल कक्षा के इरादे से संबंधित विधियां।

निम्न सामंजस्य का उदाहरण:

-------------------
| Staff           |
-------------------
| checkEmail()    |
| sendEmail()     |
| emailValidate() |
| PrintLetter()   |
-------------------

उच्च सामंजस्य का उदाहरण:

----------------------------
| Staff                   |
----------------------------
| -salary                 |
| -emailAddr              |
----------------------------
| setSalary(newSalary)    |
| getSalary()             |
| setEmailAddr(newEmail)  |
| getEmailAddr()          |
----------------------------

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

अच्छे सॉफ्टवेयर डिज़ाइन में उच्च सामंजस्य और कम युग्मन होता है


12
मैं नहीं देखता कि कुछ तरीकों को कैसे हटाया जाए, और कुछ को जोड़ने से सामंजस्य बढ़ता है। किसी कृपया यहाँ मदद कर सकते हैं?
साकेत जैन २

3
@SaketJain यह सिर्फ कुछ तरीकों को हटाने और कुछ अन्य को जोड़ने के लिए नहीं है। यह है कि विधियाँ कक्षा के उद्देश्य से कैसे संबंधित हैं (यदि वह स्पष्टीकरण स्पष्ट है)।
मौरिस

4
शीर्ष पर कम सामंजस्य के उदाहरण बहुत अच्छा लग रहा है, मुझे लगता है कि अगर आप गलती से कहने के लिए "उच्च cohession" का मतलब है
relipse

37
@SaketJain कर्मचारी वर्ग वह स्थान नहीं है जहाँ हम ईमेल की जाँच करते हैं, भेजते हैं या उसे सत्यापित करते हैं। उन कार्यों को एक काल्पनिक ईमेल वर्ग के अंदर जाना चाहिए, यही कारण है कि यह एक कम सामंजस्य है। दूसरे उदाहरण में कर्मचारी वर्ग में स्टाफ से संबंधित डेटा को स्थापित करने और प्राप्त करने के लिए केवल उचित जानकारी है। वे ऐसी क्रियाएं नहीं करते हैं जिन्हें किसी अन्य वर्ग द्वारा प्रबंधित किया जाना चाहिए।
एंटोनियो पेंटानो

3
@JonathanC के उदाहरणों को अभी भी एक उदाहरण होने के लिए अंतर (गणित प्रमाण की तरह) साबित करने की आवश्यकता नहीं है। बेझिझक उत्तर दें या कोई टिप्पणी करें जो आपको लगता है कि अधिक सहायक हैं। setऔर getकार्यों यह दर्शाते हैं कि "कर्मचारी" संदर्भ से अधिक विशिष्ट है कार्यक्षमता - उच्च विशिष्टता दे कि उदाहरण अपनी उच्च सामंजस्य।
cellepo

81

सामंजस्य एक मॉड्यूल के भीतर संबंध का संकेत है ।

युग्मन मॉड्यूल के बीच संबंधों का संकेत है ।

यहाँ छवि विवरण दर्ज करें

एकजुटता

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

युग्मन

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

इस लिंक की जाँच करें


77

मॉड्यूल के भीतर उच्च सामंजस्य और बीच में कम युग्मन को अक्सर OO प्रोग्रामिंग भाषाओं में उच्च गुणवत्ता से संबंधित माना जाता है।

उदाहरण के लिए, प्रत्येक जावा वर्ग के अंदर कोड में उच्च आंतरिक सामंजस्य होना चाहिए, लेकिन अन्य जावा कक्षाओं में कोड के लिए जितना संभव हो उतना शिथिल होना चाहिए।

मेयर के ऑब्जेक्ट-ओरिएंटेड सॉफ्टवेयर कंस्ट्रक्शन (द्वितीय संस्करण) के अध्याय 3 में इन मुद्दों का शानदार वर्णन है।


3
अवधारणाएं वास्तव में OO प्रोग्रामिंग तक सीमित नहीं हैं। यदि कुछ भी हो, तो मैं सुझाव दूंगा कि ऊ भाषाओं का एक लक्ष्य प्रोग्रामर को उच्च सामंजस्य / कम युग्मन के उद्देश्यों के लिए मार्गदर्शन करना है।
हच

57

सामंजस्य इस बात का संकेत है कि सॉफ्टवेयर तत्व की जिम्मेदारियां कितनी संबंधित और केंद्रित हैं।

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

सॉफ्टवेयर तत्व क्लास, पैकेज, कंपोनेंट, सबसिस्टम या एक सिस्टम हो सकता है। और सिस्टम को डिजाइन करते समय यह सॉफ्टवेयर तत्वों की सिफारिश की जाती है जिनमें उच्च सामंजस्य होता है और कम युग्मन का समर्थन करता है ।

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

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

  1. समर्थन एक कनेक्शन हो रहा है
  2. एक कनेक्शन जारी करें
  3. कनेक्शन बनाम उपयोग गणना के बारे में आंकड़े प्राप्त करें
  4. समय बनाम कनेक्शन के बारे में आंकड़े प्राप्त करें
  5. कनेक्शन पुनर्प्राप्ति को संग्रहीत करें और बाद में रिपोर्टिंग के लिए डेटाबेस के लिए जानकारी जारी करें।

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

कम सामंजस्य कनेक्शन पूल

उच्च सामंजस्य के साथ हम कक्षाओं में इन जिम्मेदारी को सौंप सकते हैं और इसे और अधिक बनाए रखने और पुन: प्रयोज्य बना सकते हैं।

उच्च सामंजस्य कनेक्शन पूल

कम युग्मन को प्रदर्शित करने के लिए हम ConnectionPoolऊपर उच्च सामंजस्य आरेख के साथ जारी रखेंगे । यदि हम उपरोक्त आरेख को देखते हैं, हालांकि यह उच्च सामंजस्य का समर्थन करता है, तो ConnectionPoolकसकर ConnectionStatisticsवर्ग के साथ जोड़ा जाता है और PersistentStoreयह सीधे उनके साथ बातचीत करता है। युग्मन को कम करने के बजाय हम एक ConnectionListenerइंटरफ़ेस पेश कर सकते हैं और इन दो वर्गों को इंटरफ़ेस लागू करने और उन्हें ConnectionPoolकक्षा के साथ पंजीकृत करने दें । और ConnectionPoolइन श्रोताओं के माध्यम से पुनरावृत्ति करेगा और उन्हें कनेक्शन प्राप्त करने और घटनाओं को जारी करने की सूचना देगा और कम युग्मन की अनुमति देगा।

कम युग्मन कनेक्शनपूल

नोट / शब्द या सावधानी: इस सरल परिदृश्य के लिए यह एक ओवरकिल की तरह लग सकता है, लेकिन अगर हम एक वास्तविक समय के परिदृश्य की कल्पना करते हैं, जहां हमारे आवेदन को लेनदेन पूरा करने के लिए कई तृतीय पक्ष सेवाओं के साथ बातचीत करने की आवश्यकता है: सीधे हमारे कोड को तीसरे पक्ष की सेवाओं के साथ युग्मित करना इसका मतलब यह होगा कि तीसरे पक्ष की सेवा में किसी भी परिवर्तन से कई स्थानों पर हमारे कोड में परिवर्तन हो सकता है, इसके बजाय हम Facadeआंतरिक सेवाओं के साथ इन एकाधिक सेवाओं के साथ सहभागिता कर सकते हैं और सेवाओं में कोई भी परिवर्तन Facadeतीसरे पक्ष के साथ कम युग्मन के लिए स्थानीय हो सकते हैं और लागू कर सकते हैं। सेवाएं।


3
बहुत बढ़िया जवाब! यदि संभव हो, तो क्या आप कुछ अन्य उदाहरण का उपयोग कर सकते हैं? कनेक्शन पूलिंग सभी के लिए स्पष्ट नहीं हो सकती है। बावजूद, इसने वास्तव में मेरी मदद की। तो धन्यवाद!
साकेत जैन २

ConnectionListener इंटरफ़ेस का उपयोग कपलिंग को कम करने में कैसे मदद करता है? क्या आप एक ऐसा उदाहरण प्रदान कर सकते हैं जो समझने में आसान हो।
अभिषेक गुप्ता

1
@abhishekgupta इस उदाहरण में आपने देखा होगा कि हमने कम / ढीली युग्मन प्राप्त करने के लिए पर्यवेक्षक पैटर्न का उपयोग किया है। इसके माध्यम से जाने में मदद मिलेगी कि ऑब्ज़र्वर शिथिल-युग्मित डिज़ाइन कैसे बनाते हैं?
मधुसूदन रेड्डी सुननपु

33

बढ़े हुए सामंजस्य और घटे हुए युग्मन से अच्छे सॉफ़्टवेयर डिज़ाइन बनते हैं।

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

Decoupling आपको अपने सॉफ़्टवेयर के अन्य भागों को प्रभावित किए बिना कार्यान्वयन को बदलने की अनुमति देता है।

सामंजस्य सुनिश्चित करता है कि कार्यान्वयन कार्यक्षमता के लिए अधिक विशिष्ट है और उसी समय बनाए रखना आसान है।

घटती युग्मन और बढ़ती सामंजस्य की सबसे प्रभावी विधि इंटरफ़ेस द्वारा डिजाइन है

यह प्रमुख कार्यात्मक वस्तुओं को इंटरफेस (ओं) के माध्यम से केवल एक-दूसरे को जानना चाहिए। एक इंटरफ़ेस का कार्यान्वयन एक प्राकृतिक परिणाम के रूप में सामंजस्य का परिचय देता है।

कुछ सीरियसनेस में यथार्थवादी नहीं होने के बावजूद यह काम करने के लिए एक डिज़ाइन लक्ष्य होना चाहिए।

उदाहरण (बहुत स्केच):

public interface IStackoverFlowQuestion
      void SetAnswered(IUserProfile user);
      void VoteUp(IUserProfile user);
      void VoteDown(IUserProfile user);
}

public class NormalQuestion implements IStackoverflowQuestion {
      protected Integer vote_ = new Integer(0);
      protected IUserProfile user_ = null;
      protected IUserProfile answered_ = null;

      public void VoteUp(IUserProfile user) {
           vote_++;
           // code to ... add to user profile
      }

      public void VoteDown(IUserProfile user) {
          decrement and update profile
      }

      public SetAnswered(IUserProfile answer) {
           answered_ = answer
           // update u
      }
}

public class CommunityWikiQuestion implements IStackoverflowQuestion {
     public void VoteUp(IUserProfile user) { // do not update profile }
     public void VoteDown(IUserProfile user) { // do not update profile }
     public void SetAnswered(IUserProfile user) { // do not update profile }
}

आपके कोडबेस में कुछ और जहां आपके पास एक मॉड्यूल हो सकता है जो सवालों की प्रक्रिया करता है कि वे क्या हैं:

public class OtherModuleProcessor {
    public void Process(List<IStackoverflowQuestion> questions) {
       ... process each question.
    }
}

28

सामंजस्य का सबसे अच्छा विवरण अंकल बॉब के क्लीन कोड से आता है:

कक्षाओं में उदाहरण चर की एक छोटी संख्या होनी चाहिए। कक्षा के प्रत्येक तरीकों में से एक या एक से अधिक चर में हेरफेर करना चाहिए। सामान्य रूप से अधिक चर एक विधि अधिक सामंजस्यपूर्ण हेरफेर करता है जो विधि अपनी कक्षा के लिए है । एक वर्ग जिसमें प्रत्येक विधि द्वारा प्रत्येक चर का उपयोग किया जाता है, अधिकतम रूप से सामंजस्यपूर्ण होता है।

सामान्य तौर पर इस तरह के अधिकतम सामंजस्यपूर्ण वर्गों का निर्माण करना न तो उचित है और न ही संभव; दूसरी ओर, हम चाहते हैं कि सामंजस्य अधिक हो । जब सामंजस्य अधिक होता है, तो इसका मतलब है कि कक्षा के तरीके और चर सह-निर्भर हैं और एक तार्किक पूरे के रूप में एक साथ हैं।

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


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

13

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

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

एक सामंजस्य और युग्मन दृष्टिकोण से कोड के प्रकार:

आदर्श वह कोड है जो दिशानिर्देश का पालन करता है। यह शिथिल युग्मित और अत्यधिक सामंजस्यपूर्ण है। हम इस चित्र के साथ इस तरह के कोड को चित्रित कर सकते हैं:यहाँ छवि विवरण दर्ज करें

गॉड ऑब्जेक्ट उच्च सामंजस्य और उच्च युग्मन शुरू करने का एक परिणाम है। यह एक विरोधी पैटर्न है और मूल रूप से एक ही कोड के लिए खड़ा है जो एक ही बार में सभी काम करता है: खराब रूप से चयनित तब होता है जब विभिन्न वर्गों या मॉड्यूल के बीच की सीमाएं खराब तरीके से चुनी जाती हैंयहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें

विनाशकारी decoupling सबसे दिलचस्प एक है। यह कभी-कभी तब होता है जब एक प्रोग्रामर एक कोड बेस को इतना कम करने की कोशिश करता है कि कोड पूरी तरह से अपना ध्यान खो देता है:यहाँ छवि विवरण दर्ज करें

यहाँ और पढ़ें


1
उत्कृष्ट लेख और चित्र! अगर मैं सिर्फ एक विचार में सुधार का सुझाव दे सकता हूं, तो मुझे पसंद है कि कैसे 'खराब तरीके से चयनित' घटकों के समूहों को असंबंधित शब्दार्थों के साथ थोड़ा स्वार में रखा जाता है, लेकिन मुझे लगता है कि उनके बीच नेत्रहीन रूप से अधिक तीर होना चाहिए। आखिरकार, आपके 4-वर्गों के ग्राफ़ पर भी यह वही है जो 'युग्मन' अक्ष की ऊपरी श्रेणी में आता है।
स्लावोमिर ब्रेज़ज़िंस्की

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

अद्यतन: मैंने इन सुझावों को छवि के मूल लेखक के लिए उठाया और लेखक उनके साथ सहमत हुए
स्लावोमिर ब्रेज़ज़िंस्की

11

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

सरल शब्दों में युग्मन , कितना एक घटक है (फिर से, एक वर्ग की कल्पना करें, हालांकि जरूरी नहीं) दूसरे के आंतरिक कामकाज या आंतरिक तत्वों के बारे में जानता है, अर्थात इसके दूसरे घटक का कितना ज्ञान है।

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


4

यहाँ छवि विवरण दर्ज करें

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

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


2

सामंजस्य (सामंजस्य): सह जिसका अर्थ है एक साथ , hesion जो साधन छड़ी करने के लिए । विभिन्न पदार्थों के कणों के एक साथ चिपके रहने की प्रणाली।

वास्तविक जीवन के उदाहरण के लिए: img सौजन्य
यहाँ छवि विवरण दर्ज करें

संपूर्ण भाग-एस्ट्रोटल के योग से बड़ा है।

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

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


1

मुझे लगता है कि मतभेदों को निम्नलिखित के रूप में रखा जा सकता है:

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

इस ब्लॉग पोस्ट में मैं इसके बारे में अधिक विस्तार से लिखता हूं।


1

सामंजस्य एक मॉड्यूल के सापेक्ष कार्यात्मक शक्ति का एक संकेत है।

  • एक चिपकने वाला मॉड्यूल एक एकल कार्य करता है, जिसमें एक कार्यक्रम के अन्य हिस्सों में अन्य घटकों के साथ थोड़ी बातचीत की आवश्यकता होती है। बस कहा, एक चिपकने वाला मॉड्यूल (आदर्श रूप से) सिर्फ एक काम करना चाहिए।
  • पारंपरिक दृष्टिकोण:

    एक मॉड्यूल की "एकल-दिमाग"

  • OO देखें:

    cohesion का तात्पर्य है कि एक घटक या वर्ग केवल उन विशेषताओं और परिचालनों को सम्मिलित करता है जो एक दूसरे से और कक्षा या स्वयं से निकट से संबंधित हैं

  • सामंजस्य के sLevels

    Functional

    Layer

    Communicational

    Sequential

    Procedural

    Temporal

    utility

युग्मन मॉड्यूल के बीच सापेक्ष निर्भरता का एक संकेत है।

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

  • परम्परागत दृश्य: वह अंश जिसके लिए एक घटक अन्य घटकों और बाहरी दुनिया से जुड़ा होता है

  • OO दृश्य: डिग्री का एक गुणात्मक माप जो वर्गों को एक दूसरे से जुड़ा हुआ है

  • युग्मन का स्तर

    Content

    Common

    Control

    Stamp

    Data

    रूटीन कॉल करें

    प्रकार का उपयोग

    C समावेश या आयात

     बाहरी #


1

युग्मन = दो मॉड्यूल के बीच बातचीत / संबंध ... सामंजस्य = एक मॉड्यूल के भीतर दो तत्वों के बीच बातचीत।

एक सॉफ्टवेयर कई मॉड्यूल से मिलकर बना होता है। मॉड्यूल में तत्व होते हैं। एक मॉड्यूल पर विचार एक कार्यक्रम है। एक कार्यक्रम के भीतर एक कार्य एक तत्व है।

रन टाइम में, एक प्रोग्राम का आउटपुट दूसरे प्रोग्राम के इनपुट के रूप में उपयोग किया जाता है। इसे कम्युनिकेशन को प्रोसेस करने के लिए मॉड्यूल इंटरएक्शन या प्रक्रिया को मॉड्यूल कहा जाता है। इसे कपलिंग भी कहा जाता है।

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

उदाहरण:

युग्मन = 2 विभिन्न परिवारों के बीच संचार ... सामंजस्य = एक परिवार के भीतर पिता-माता-बच्चे के बीच संचार।


1
तो आप उन्हें एक सॉफ्टवेयर पर उनके प्रभाव के संदर्भ में
इटबन सईद

एक सॉफ्टवेयर कई मॉड्यूल से मिलकर बना होता है। मॉड्यूल में तत्व होते हैं। एक मॉड्यूल पर विचार एक कार्यक्रम है। एक कार्यक्रम के भीतर एक कार्य एक तत्व है।
दीपंकर नलुई

1

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

एक वर्ग का सार्वजनिक इंटरफ़ेस सम्वेदनशील है यदि सभी वर्ग विशेषताएं उस अवधारणा से संबंधित हैं जो कक्षा का प्रतिनिधित्व करती है। उदाहरण के लिए, CashRegister क्लास होने के बजाय, CashRegister और Coin के फीचर्स का सामंजस्य होने के कारण इसे 2 वर्गों में रखा जाता है - CashRegister और Coin क्लास।

में युग्मन , एक वर्ग दूसरे पर निर्भर करता है क्योंकि यह वर्ग की वस्तुओं का उपयोग करता है।

उच्च युग्मन के साथ समस्या यह है कि यह दुष्प्रभाव पैदा कर सकता है। एक वर्ग में एक परिवर्तन से दूसरे वर्ग में अप्रत्याशित त्रुटि हो सकती है और पूरे कोड को तोड़ सकता है।

आमतौर पर, उच्च सामंजस्य और कम युग्मन को उच्च गुणवत्ता वाला OOP माना जाता है।


0

शब्द सामंजस्य वास्तव में सॉफ्टवेयर डिजाइन में इसका क्या अर्थ है के लिए थोड़ा काउंटर सहज है।

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

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

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


लोग वर्ग के बजाय शब्द मॉड्यूल का उपयोग क्यों करते हैं?
उत्तरवासी

1
@northerner इसकी सिर्फ अधिक सामान्य शब्द है।
zar

0

थ्योरी अंतर

एकजुटता

  • सामंजस्य मॉड्यूल के सापेक्ष कार्यात्मक शक्ति का एक संकेत है।
  • एक चिपकने वाला मॉड्यूल एक ही कार्य करता है, जिसमें कार्यक्रम के अन्य हिस्सों में अन्य घटकों के साथ थोड़ी बातचीत की आवश्यकता होती है।
  • एक मॉड्यूल जिसमें उच्च सामंजस्य और कम युग्मन होता है, को कार्यात्मक रूप से अन्य मॉड्यूल से स्वतंत्र कहा जाता है।

सामंजस्य का वर्गीकरण

1. कॉनडेंटल 2.लोगिकल 3. टेम्परल 4.प्रतिष्ठित 5. संचार 6. पर्याप्त 7.Functional

युग्मन

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