language agnostic - यूएमएल संबंध-धराशायी रेखा बनाम ठोस रेखा




language-agnostic uml (4)

आपके सवाल ने मुझे खुद को सीखने का एक अच्छा मौका दिया, यहाँ मैंने जो पाया -

एसोसिएशन : एक अन्य प्रकार का स्वामित्व (जैसे 'ए' का मालिक 'बी' है)

//@assoc  The Player(A) has some Dice(B)
class Player {
    Dice myDice;
}

निर्भरता : दूसरे प्रकार का उपयोग (जैसे 'C' एक 'D' का उपयोग करता है)

//@dep    The Player(C) uses some Dice(D) when playing a game
class Player {
    rollYahtzee(Dice someDice);
}

यहाँ एक कुरकुरा रेफरी मैंने पाया - एसोसिएशन बनाम निर्भरता

इन 2 रिश्तों में क्या अंतर है?

संपादित करें: यदि आप अंतर को दर्शाते हुए एक सरल कोड उदाहरण प्रदान कर सकते हैं, तो यह वास्तव में उपयोगी होगा!


ठीक है, चूंकि आपने पहले उत्तर को स्वीकार नहीं किया था; मुझे कोशिश करने दो।

तीर 1: एक सामान्य संघ

यूएमएल में विभिन्न प्रकार की लाइनें और तीर हैं। ऊपर साधारण एसोसिएशन तीर है, इसका मतलब है कि एक वर्ग में दूसरे वर्ग के लिए लिंक हो सकता है। नीचे मैं कोड उदाहरणों के साथ प्रत्येक प्रकार की व्याख्या करूंगा।

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

हम इसे आमतौर पर कोड में कैसे पूरा करते हैं?

class Husband{
    Wife bestWomanInTheWorld;

    public Husband(Wife theWife){
        this.bestWomanInTheWorld = theWife;
    }
}

क्योंकि पति को हमेशा एक पत्नी की आवश्यकता होती है , हम निर्माणकर्ता में आवश्यक संबंध रखते हैं। क्योंकि एक कलाकार के पास गिटार हो सकता है, हम कंस्ट्रक्टर को इस तरह से खाली छोड़ देंगे:

class Artist{
    List<Guitar> guitars;

    public Artist(){
    }

    public AddGuitarToCollection(Guitar newGuitar){
        Guitars.Add(newGuitar);
    }
}

तो, यह है कि हम इसे कोड में कैसे पूरा करते हैं (अधिकांश समय!)। यदि आप प्रोग्रामिंग में नए हैं, तो आपको आमतौर पर विभिन्न प्रकार की लाइनों और तीरों की आवश्यकता नहीं होगी। इसे सरल रखें।

तीर 2: निर्भरता

ठीक है, इसलिए हम सामान्य संघों के बारे में जानते हैं जो हम ज्यादातर समय का उपयोग करेंगे। लेकिन हम 'निर्भरता' तीर का उपयोग कब करेंगे? खैर, एक निर्भरता (विकिपीडिया) को परिभाषित करने देता है:

Dependency is a weaker form of bond which indicates that one class depends on 
another because it uses it at some point in time. One class depends on 
another if the independent class is a parameter variable or local variable of 
a method of the dependent class. This is different from an association, where 
an attribute of the dependent class is an instance of the independent class. 
Sometimes the relationship between two classes is very weak. They are not 
implemented with member variables at all. Rather they might be implemented as 
member function arguments.

अगर कोई संबंध, संबंध, संबंध आदि है, जो काम करने के लिए, क्लास ए के लिए मौजूद होना चाहिए; यह एक निर्भरता है। उदाहरण: पति को पत्नी की आवश्यकता है। कार (और ड्राइव) होने के लिए कार को एक पहिया की आवश्यकता होती है। कार फैक्ट्री को इससे ऑब्जेक्ट बनाने के लिए कार क्लास की जरूरत होती है। आपके RSSNewsItem वर्ग को कुछ भी करने के लिए XMLReader वर्ग की आवश्यकता है

कब कौन सा उपयोग करें?

वैसे, मेरी नज़र में यह एकमात्र वैध प्रश्न है; चूँकि Google आपके प्रश्न के मान्य उत्तर का एक बहुत कुछ दिखाता है। वर्ग आरेख में निर्भरता का उपयोग कभी न करने का प्रयास करें क्योंकि आमतौर पर इसका मतलब है कि आप पर्याप्त विशिष्ट नहीं हैं। हमेशा संघों, वास्तविकताओं इत्यादि के लिए लक्ष्य रखें (केवल मेरी राय में) यदि किसी संबंध को बनाए रखने के बिना किसी अन्य वर्ग का उपयोग करने की आवश्यकता है तो। उदाहरण; उपयोगिता वर्ग (XMLReader की तरह)।

यदि आपके पास इस पूरी व्याख्या को पढ़ने के बाद कोई सवाल है, तो बेझिझक पूछें। :-)


बिंदीदार रेखा (तीर की दिशा में) निर्भरता को इंगित करती है। यह मानकर कि आपने अपने स्रोत कोड को बड़े स्तर पर अलग-अलग फ़ाइलों और प्रत्येक वर्ग के हेडर में इकट्ठा किया है - यह दूर है कि कोड में लाइन #include ClassB.h शामिल है।

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

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

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


मैं दो प्रकार की रेखाओं के सरल उदाहरण देने की कोशिश कर रहा हूं।

पहले आरेख में, ठोस रेखा एक संघ दिखाती है:

यदि कक्षाओं को जावा में घोषित किया गया था, तो यह ClassB तरह होगा जो एक विशेषता के रूप में ClassB संदर्भ को ClassB करता है (इसे कंस्ट्रक्टर को बनाया जा सकता है, बनाया जा सकता है, आदि)। तो, आप कुछ इस तरह देख सकते हैं:

public class ClassA {
    ClassB theClassB = ...
    ...
}

दूसरे आरेख में, यह एक निर्भरता दिखाता है:

एक निर्भरता एक संघ की तुलना में बहुत कमजोर है। यूएमएल डिस्टिल्ड से उद्धृत करने के लिए:

कक्षाओं के साथ, विभिन्न कारणों से निर्भरताएं मौजूद हैं: एक वर्ग दूसरे को संदेश भेजता है; एक वर्ग के डेटा के हिस्से के रूप में एक और है; एक वर्ग एक ऑपरेशन के पैरामीटर के रूप में दूसरे का उल्लेख करता है। [...] आप निर्भरता का उपयोग करते हैं जब भी आप दिखाना चाहते हैं कि एक तत्व में परिवर्तन अन्य तत्वों को कैसे बदल सकता है।

फिर से, जावा का उपयोग करते हुए, कुछ उदाहरण मौजूद हैं: ClassB का एक तर्क एक विधि के लिए दिया जाता है, या एक विधि ClassB स्थानीय चर घोषित करता है:

public class ClassA {
    ...
    public void someMethod(ClassB arg1) {...}
    ...
    public void someOtherMethod() {
        ClassB localReferenceToClassB = ...
    }
    ...
}

अन्य तरीके ClassB बिना ClassB पर निर्भर हो सकते हैं (एक विस्तृत सूची नहीं):

  • ClassB में एक स्थिर विधि है जिसे ClassB कॉल करता है
  • ClassB अपवादों को पकड़ता है
  • जब भी ClassB को संशोधित किया जाता है, ClassB को भी संशोधित किया जाना चाहिए (जैसे, कुछ तर्क साझा किए जाते हैं)




class-diagram