सामंजस्य और युग्मन के बीच अंतर क्या है?
कैसे युग्मन और सामंजस्य या तो अच्छे या खराब सॉफ्टवेयर डिजाइन को जन्म दे सकता है?
कुछ उदाहरण क्या हैं जो दोनों के बीच अंतर को रेखांकित करते हैं, और समग्र कोड गुणवत्ता पर उनका प्रभाव है?
सामंजस्य और युग्मन के बीच अंतर क्या है?
कैसे युग्मन और सामंजस्य या तो अच्छे या खराब सॉफ्टवेयर डिजाइन को जन्म दे सकता है?
कुछ उदाहरण क्या हैं जो दोनों के बीच अंतर को रेखांकित करते हैं, और समग्र कोड गुणवत्ता पर उनका प्रभाव है?
जवाबों:
सामंजस्य से तात्पर्य वर्ग (या मॉड्यूल) से क्या हो सकता है। कम सामंजस्य का मतलब यह होगा कि वर्ग कई प्रकार के कार्यों को करता है - यह व्यापक है, जो इसे करना चाहिए। उच्च सामंजस्य का मतलब है कि वर्ग इस पर केंद्रित है कि उसे क्या करना चाहिए, अर्थात केवल कक्षा के इरादे से संबंधित विधियां।
निम्न सामंजस्य का उदाहरण:
-------------------
| Staff |
-------------------
| checkEmail() |
| sendEmail() |
| emailValidate() |
| PrintLetter() |
-------------------
उच्च सामंजस्य का उदाहरण:
----------------------------
| Staff |
----------------------------
| -salary |
| -emailAddr |
----------------------------
| setSalary(newSalary) |
| getSalary() |
| setEmailAddr(newEmail) |
| getEmailAddr() |
----------------------------
के रूप में युग्मन , यह कैसे संबंधित या निर्भर दो वर्गों / मॉड्यूल एक दूसरे की ओर कर रहे हैं को दर्शाता है। कम युग्मित वर्गों के लिए, एक कक्षा में कुछ प्रमुख बदलने से दूसरे को प्रभावित नहीं करना चाहिए। उच्च युग्मन से आपके कोड को बदलना और बनाए रखना मुश्किल होगा; चूंकि कक्षाएं एक साथ बारीकी से बुनती हैं, इसलिए एक बदलाव से पूरे सिस्टम को सुधारने की आवश्यकता हो सकती है।
अच्छे सॉफ्टवेयर डिज़ाइन में उच्च सामंजस्य और कम युग्मन होता है ।
set
और get
कार्यों यह दर्शाते हैं कि "कर्मचारी" संदर्भ से अधिक विशिष्ट है कार्यक्षमता - उच्च विशिष्टता दे कि उदाहरण अपनी उच्च सामंजस्य।
सामंजस्य एक मॉड्यूल के भीतर संबंध का संकेत है ।
युग्मन मॉड्यूल के बीच संबंधों का संकेत है ।
एकजुटता
युग्मन
मॉड्यूल के भीतर उच्च सामंजस्य और बीच में कम युग्मन को अक्सर OO प्रोग्रामिंग भाषाओं में उच्च गुणवत्ता से संबंधित माना जाता है।
उदाहरण के लिए, प्रत्येक जावा वर्ग के अंदर कोड में उच्च आंतरिक सामंजस्य होना चाहिए, लेकिन अन्य जावा कक्षाओं में कोड के लिए जितना संभव हो उतना शिथिल होना चाहिए।
मेयर के ऑब्जेक्ट-ओरिएंटेड सॉफ्टवेयर कंस्ट्रक्शन (द्वितीय संस्करण) के अध्याय 3 में इन मुद्दों का शानदार वर्णन है।
सामंजस्य इस बात का संकेत है कि सॉफ्टवेयर तत्व की जिम्मेदारियां कितनी संबंधित और केंद्रित हैं।
कपलिंग का तात्पर्य है कि सॉफ्टवेयर तत्व अन्य तत्वों से कितनी मजबूती से जुड़ा है।
सॉफ्टवेयर तत्व क्लास, पैकेज, कंपोनेंट, सबसिस्टम या एक सिस्टम हो सकता है। और सिस्टम को डिजाइन करते समय यह सॉफ्टवेयर तत्वों की सिफारिश की जाती है जिनमें उच्च सामंजस्य होता है और कम युग्मन का समर्थन करता है ।
कम सामंजस्य का परिणाम अखंड वर्गों में होता है जिन्हें बनाए रखना, समझना और पुन: उपयोग को कम करना मुश्किल होता है। इसी प्रकार उच्च युग्मन के परिणाम उन कक्षाओं में होते हैं जो बहुत अच्छे से युग्मित होते हैं और परिवर्तन गैर-स्थानीय नहीं होते हैं, पुन: उपयोग को बदलना और कम करना मुश्किल होता है।
हम एक काल्पनिक परिदृश्य ले सकते हैं जहां हम एक विशिष्ट मॉनीटर डिजाइन कर रहे हैं ConnectionPool
, जो निम्न आवश्यकताओं के साथ सक्षम है । ध्यान दें, यह एक साधारण वर्ग के लिए बहुत अधिक लग सकता है, ConnectionPool
लेकिन मूल इरादा सिर्फ कुछ सरल उदाहरण के साथ कम युग्मन और उच्च सामंजस्य का प्रदर्शन करना है और मुझे लगता है कि मदद करनी चाहिए।
कम सामंजस्य के साथ हम ConnectionPool
नीचे एक एकल वर्ग में इस सभी कार्यक्षमता / जिम्मेदारियों को जबरदस्ती भरकर एक वर्ग डिजाइन कर सकते हैं। हम देख सकते हैं कि यह एकल वर्ग कनेक्शन प्रबंधन के लिए जिम्मेदार है, डेटाबेस के साथ बातचीत करने के साथ-साथ कनेक्शन आँकड़े बनाए रखता है।
उच्च सामंजस्य के साथ हम कक्षाओं में इन जिम्मेदारी को सौंप सकते हैं और इसे और अधिक बनाए रखने और पुन: प्रयोज्य बना सकते हैं।
कम युग्मन को प्रदर्शित करने के लिए हम ConnectionPool
ऊपर उच्च सामंजस्य आरेख के साथ जारी रखेंगे । यदि हम उपरोक्त आरेख को देखते हैं, हालांकि यह उच्च सामंजस्य का समर्थन करता है, तो ConnectionPool
कसकर ConnectionStatistics
वर्ग के साथ जोड़ा जाता है और PersistentStore
यह सीधे उनके साथ बातचीत करता है। युग्मन को कम करने के बजाय हम एक ConnectionListener
इंटरफ़ेस पेश कर सकते हैं और इन दो वर्गों को इंटरफ़ेस लागू करने और उन्हें ConnectionPool
कक्षा के साथ पंजीकृत करने दें । और ConnectionPool
इन श्रोताओं के माध्यम से पुनरावृत्ति करेगा और उन्हें कनेक्शन प्राप्त करने और घटनाओं को जारी करने की सूचना देगा और कम युग्मन की अनुमति देगा।
नोट / शब्द या सावधानी: इस सरल परिदृश्य के लिए यह एक ओवरकिल की तरह लग सकता है, लेकिन अगर हम एक वास्तविक समय के परिदृश्य की कल्पना करते हैं, जहां हमारे आवेदन को लेनदेन पूरा करने के लिए कई तृतीय पक्ष सेवाओं के साथ बातचीत करने की आवश्यकता है: सीधे हमारे कोड को तीसरे पक्ष की सेवाओं के साथ युग्मित करना इसका मतलब यह होगा कि तीसरे पक्ष की सेवा में किसी भी परिवर्तन से कई स्थानों पर हमारे कोड में परिवर्तन हो सकता है, इसके बजाय हम Facade
आंतरिक सेवाओं के साथ इन एकाधिक सेवाओं के साथ सहभागिता कर सकते हैं और सेवाओं में कोई भी परिवर्तन Facade
तीसरे पक्ष के साथ कम युग्मन के लिए स्थानीय हो सकते हैं और लागू कर सकते हैं। सेवाएं।
बढ़े हुए सामंजस्य और घटे हुए युग्मन से अच्छे सॉफ़्टवेयर डिज़ाइन बनते हैं।
सामंजस्य आपकी कार्यक्षमता को विभाजित करता है ताकि यह संक्षिप्त हो और इसके लिए प्रासंगिक डेटा के सबसे करीब हो, जबकि डिकॉउप्लिंग यह सुनिश्चित करता है कि कार्यात्मक कार्यान्वयन बाकी सिस्टम से अलग है।
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.
}
}
सामंजस्य का सबसे अच्छा विवरण अंकल बॉब के क्लीन कोड से आता है:
कक्षाओं में उदाहरण चर की एक छोटी संख्या होनी चाहिए। कक्षा के प्रत्येक तरीकों में से एक या एक से अधिक चर में हेरफेर करना चाहिए। सामान्य रूप से अधिक चर एक विधि अधिक सामंजस्यपूर्ण हेरफेर करता है जो विधि अपनी कक्षा के लिए है । एक वर्ग जिसमें प्रत्येक विधि द्वारा प्रत्येक चर का उपयोग किया जाता है, अधिकतम रूप से सामंजस्यपूर्ण होता है।
सामान्य तौर पर इस तरह के अधिकतम सामंजस्यपूर्ण वर्गों का निर्माण करना न तो उचित है और न ही संभव; दूसरी ओर, हम चाहते हैं कि सामंजस्य अधिक हो । जब सामंजस्य अधिक होता है, तो इसका मतलब है कि कक्षा के तरीके और चर सह-निर्भर हैं और एक तार्किक पूरे के रूप में एक साथ हैं।
कार्यों को छोटा रखने और पैरामीटर सूचियों को छोटा रखने की रणनीति कभी-कभी उदाहरण चर के प्रसार का कारण बन सकती है जो विधियों के सबसेट द्वारा उपयोग की जाती हैं। जब ऐसा होता है, तो इसका लगभग हमेशा मतलब होता है कि कम से कम एक अन्य वर्ग बड़े वर्ग से बाहर निकलने की कोशिश कर रहा है। आपको चर और विधियों को दो या अधिक वर्गों में अलग करने का प्रयास करना चाहिए, जैसे कि नई कक्षाएं अधिक सामंजस्यपूर्ण हों।
बस, सामंजस्य उस डिग्री का प्रतिनिधित्व करता है जिसके लिए कोड आधार का एक हिस्सा तार्किक रूप से एकल, परमाणु इकाई बनाता है। दूसरी ओर, युग्मन , उस डिग्री का प्रतिनिधित्व करता है, जिसकी एक इकाई दूसरों से स्वतंत्र है। दूसरे शब्दों में, यह दो या दो से अधिक इकाइयों के बीच कनेक्शन की संख्या है। कम संख्या, युग्मन कम।
संक्षेप में, उच्च सामंजस्य का अर्थ है एक कोड आधार के कुछ हिस्सों को रखना जो एक ही स्थान पर एक दूसरे से संबंधित हैं। कम युग्मन, एक ही समय में, कोड आधार के असंबंधित भागों को यथासंभव अलग करने के बारे में है।
एक सामंजस्य और युग्मन दृष्टिकोण से कोड के प्रकार:
आदर्श वह कोड है जो दिशानिर्देश का पालन करता है। यह शिथिल युग्मित और अत्यधिक सामंजस्यपूर्ण है। हम इस चित्र के साथ इस तरह के कोड को चित्रित कर सकते हैं:
गॉड ऑब्जेक्ट उच्च सामंजस्य और उच्च युग्मन शुरू करने का एक परिणाम है। यह एक विरोधी पैटर्न है और मूल रूप से एक ही कोड के लिए खड़ा है जो एक ही बार में सभी काम करता है: खराब रूप से चयनित तब होता है जब विभिन्न वर्गों या मॉड्यूल के बीच की सीमाएं खराब तरीके से चुनी जाती हैं
विनाशकारी decoupling सबसे दिलचस्प एक है। यह कभी-कभी तब होता है जब एक प्रोग्रामर एक कोड बेस को इतना कम करने की कोशिश करता है कि कोड पूरी तरह से अपना ध्यान खो देता है:
यहाँ और पढ़ें
सॉफ्टवेयर इंजीनियरिंग में सामंजस्य वह डिग्री है जिसमें एक निश्चित मॉड्यूल के तत्व एक साथ होते हैं। इस प्रकार, यह एक माप है कि सॉफ्टवेयर मॉड्यूल के स्रोत कोड द्वारा व्यक्त कार्यक्षमता का प्रत्येक टुकड़ा कितनी दृढ़ता से संबंधित है।
सरल शब्दों में युग्मन , कितना एक घटक है (फिर से, एक वर्ग की कल्पना करें, हालांकि जरूरी नहीं) दूसरे के आंतरिक कामकाज या आंतरिक तत्वों के बारे में जानता है, अर्थात इसके दूसरे घटक का कितना ज्ञान है।
मैंने इस बारे में एक ब्लॉग पोस्ट लिखी , यदि आप उदाहरणों और रेखाचित्रों के साथ थोड़ा और विवरण पढ़ना चाहते हैं। मुझे लगता है कि यह आपके अधिकांश सवालों के जवाब देता है।
सामंजस्य सभी को संदर्भित करता है कि एक एकल वर्ग कैसे डिज़ाइन किया गया है। सामंजस्य ऑब्जेक्ट ओरिएंटेड सिद्धांत है जो यह सुनिश्चित करता है कि एक एकल, अच्छी तरह से केंद्रित उद्देश्य के साथ डिजाइन किया गया है। एक वर्ग जितना अधिक ध्यान केंद्रित करता है, उस वर्ग का सामंजस्य उतना ही अधिक होता है। उच्च सामंजस्य के फायदे यह है कि इस तरह की कक्षाएं कम सामंजस्य वाले वर्गों की तुलना में बनाए रखने के लिए (और अक्सर कम बदले जाने वाले) बहुत आसान हैं। उच्च सामंजस्य का एक और लाभ यह है कि अच्छी तरह से केंद्रित उद्देश्य के साथ कक्षाएं अन्य वर्गों की तुलना में अधिक पुन: प्रयोज्य होती हैं।
उपरोक्त छवि में, हम देख सकते हैं कि कम सामंजस्य में केवल एक वर्ग बहुत सारी नौकरी निष्पादित करने के लिए जिम्मेदार है जो सामान्य नहीं हैं जो पुन: प्रयोज्य और रखरखाव की संभावना को कम करता है। लेकिन उच्च सामंजस्य में एक विशिष्ट नौकरी को निष्पादित करने के लिए सभी नौकरियों के लिए एक अलग वर्ग है, जिसके परिणामस्वरूप बेहतर उपयोगिता और रखरखाव होता है।
सामंजस्य (सामंजस्य): सह जिसका अर्थ है एक साथ , hesion जो साधन छड़ी करने के लिए । विभिन्न पदार्थों के कणों के एक साथ चिपके रहने की प्रणाली।
वास्तविक जीवन के उदाहरण के लिए: img सौजन्य
संपूर्ण भाग-एस्ट्रोटल के योग से बड़ा है।
सामंजस्य एक सामान्य प्रकार का माप है और इसे आमतौर पर "उच्च सामंजस्य" या "निम्न सामंजस्य" के रूप में वर्णित किया जाता है। उच्च सामंजस्य वाले मॉड्यूल बेहतर होते हैं, क्योंकि उच्च सामंजस्य सॉफ्टवेयर के कई वांछनीय लक्षणों के साथ जुड़ा हुआ है जिसमें मजबूती, विश्वसनीयता, पुन: प्रयोज्य और समझ शामिल है। इसके विपरीत, कम सामंजस्य अवांछनीय लक्षणों के साथ जुड़ा हुआ है जैसे कि बनाए रखना, परीक्षण करना, पुन: उपयोग करना, या यहां तक कि समझना मुश्किल है। विकि
युग्मन आमतौर पर सामंजस्य के साथ विपरीत होता है । कम युग्मन अक्सर उच्च सामंजस्य के साथ सहसंबंधित होता है, और इसके विपरीत। कम युग्मन अक्सर एक अच्छी तरह से संरचित कंप्यूटर सिस्टम और एक अच्छे डिज़ाइन का संकेत होता है, और जब उच्च सामंजस्य के साथ संयुक्त होता है, तो उच्च पठनीयता और स्थिरता के सामान्य लक्ष्यों का समर्थन करता है। विकि
मुझे लगता है कि मतभेदों को निम्नलिखित के रूप में रखा जा सकता है:
इस ब्लॉग पोस्ट में मैं इसके बारे में अधिक विस्तार से लिखता हूं।
सामंजस्य एक मॉड्यूल के सापेक्ष कार्यात्मक शक्ति का एक संकेत है।
पारंपरिक दृष्टिकोण:
एक मॉड्यूल की "एकल-दिमाग"
OO देखें:
cohesion का तात्पर्य है कि एक घटक या वर्ग केवल उन विशेषताओं और परिचालनों को सम्मिलित करता है जो एक दूसरे से और कक्षा या स्वयं से निकट से संबंधित हैं
सामंजस्य के sLevels
Functional
Layer
Communicational
Sequential
Procedural
Temporal
utility
युग्मन मॉड्यूल के बीच सापेक्ष निर्भरता का एक संकेत है।
युग्मन मॉड्यूल के बीच इंटरफ़ेस जटिलता पर निर्भर करता है, वह बिंदु जिस पर एक मॉड्यूल में प्रवेश या संदर्भ होता है, और इंटरफ़ेस के पार कौन सा डेटा पास होता है।
परम्परागत दृश्य: वह अंश जिसके लिए एक घटक अन्य घटकों और बाहरी दुनिया से जुड़ा होता है
OO दृश्य: डिग्री का एक गुणात्मक माप जो वर्गों को एक दूसरे से जुड़ा हुआ है
युग्मन का स्तर
Content
Common
Control
Stamp
Data
रूटीन कॉल करें
प्रकार का उपयोग
C समावेश या आयात
बाहरी #
युग्मन = दो मॉड्यूल के बीच बातचीत / संबंध ... सामंजस्य = एक मॉड्यूल के भीतर दो तत्वों के बीच बातचीत।
एक सॉफ्टवेयर कई मॉड्यूल से मिलकर बना होता है। मॉड्यूल में तत्व होते हैं। एक मॉड्यूल पर विचार एक कार्यक्रम है। एक कार्यक्रम के भीतर एक कार्य एक तत्व है।
रन टाइम में, एक प्रोग्राम का आउटपुट दूसरे प्रोग्राम के इनपुट के रूप में उपयोग किया जाता है। इसे कम्युनिकेशन को प्रोसेस करने के लिए मॉड्यूल इंटरएक्शन या प्रक्रिया को मॉड्यूल कहा जाता है। इसे कपलिंग भी कहा जाता है।
एक कार्यक्रम के भीतर, एक फ़ंक्शन का आउटपुट दूसरे फ़ंक्शन को दिया जाता है। इसे एक मॉड्यूल के भीतर तत्वों की बातचीत कहा जाता है। इसे सहवास भी कहा जाता है।
उदाहरण:
युग्मन = 2 विभिन्न परिवारों के बीच संचार ... सामंजस्य = एक परिवार के भीतर पिता-माता-बच्चे के बीच संचार।
सीधे शब्दों में कहें तो सामंजस्य का मतलब है कि एक वर्ग को एक अवधारणा का प्रतिनिधित्व करना चाहिए।
एक वर्ग का सार्वजनिक इंटरफ़ेस सम्वेदनशील है यदि सभी वर्ग विशेषताएं उस अवधारणा से संबंधित हैं जो कक्षा का प्रतिनिधित्व करती है। उदाहरण के लिए, CashRegister क्लास होने के बजाय, CashRegister और Coin के फीचर्स का सामंजस्य होने के कारण इसे 2 वर्गों में रखा जाता है - CashRegister और Coin क्लास।
में युग्मन , एक वर्ग दूसरे पर निर्भर करता है क्योंकि यह वर्ग की वस्तुओं का उपयोग करता है।
उच्च युग्मन के साथ समस्या यह है कि यह दुष्प्रभाव पैदा कर सकता है। एक वर्ग में एक परिवर्तन से दूसरे वर्ग में अप्रत्याशित त्रुटि हो सकती है और पूरे कोड को तोड़ सकता है।
आमतौर पर, उच्च सामंजस्य और कम युग्मन को उच्च गुणवत्ता वाला OOP माना जाता है।
शब्द सामंजस्य वास्तव में सॉफ्टवेयर डिजाइन में इसका क्या अर्थ है के लिए थोड़ा काउंटर सहज है।
सामंजस्य का सामान्य अर्थ यह है कि एक चीज जो अच्छी तरह से एक साथ चिपक जाती है, एकजुट होती है, जो आणविक आकर्षण जैसे मजबूत बंधन की विशेषता होती है। हालांकि सॉफ्टवेयर डिजाइन में, इसका मतलब है कि एक वर्ग के लिए प्रयास करना जो आदर्श रूप से केवल एक ही काम करता है, इसलिए कई उप-मॉड्यूल भी शामिल नहीं हैं।
शायद हम इसे इस तरह से सोच सकते हैं। एक भाग में सबसे अधिक सामंजस्य होता है जब वह एकमात्र भाग होता है (केवल एक चीज होती है और आगे टूट नहीं सकती है)। यह वही है जो सॉफ्टवेयर डिजाइन में वांछित है। सामंजस्य बस "एकल जिम्मेदारी" या "चिंताओं को अलग करने" का दूसरा नाम है।
हाथ पर शब्द युग्मन काफी सहज है जिसका अर्थ है कि जब एक मॉड्यूल बहुत सारे अन्य मॉड्यूल पर निर्भर नहीं करता है और जो इसे जोड़ता है उसे आसानी से प्रतिस्थापित किया जा सकता है उदाहरण के लिए लिस्कोव प्रतिस्थापन सिद्धांत का पालन करना ।
1. कॉनडेंटल 2.लोगिकल 3. टेम्परल 4.प्रतिष्ठित 5. संचार 6. पर्याप्त 7.Functional