oop - वस्तु उन्मुख प्रतिमान में ढीले युग्मन और तंग युग्मन के बीच क्या अंतर है?




object coupling (10)

क्या कोई ऑब्जेक्ट उन्मुख प्रतिमान में ढीले युग्मन और तंग युग्मन के बीच सटीक अंतर का वर्णन कर सकता है?


तंग युग्मन और लूज कपलिंग के बीच कार्यक्रमवार मतभेद?

जावा ऑब्जेक्ट्स के बीच चुस्त युग्मन

class Traveler
{
    Car c=new Car();
    void startJourney()
    {
       c.move();
    }
}

class Car
{
  void move()
  {
     // logic...
  }
}

जावा ऑब्जेक्ट्स के बीच लूज युग्मन

class Traveler
{
    Vehicle v;
    public void setV(Vehicle v)
    {
      this.v = v;
    }      

    void startJourney()
    {
       v.move();
    }
}

// ========================= इंटरफ़ेस ====================== ==============

 Interface Vehicle
    {
       void move();
    }

// ==================== एकाधिक वर्ग लागू वाहन इंटरफ़ेस। प्रथम श्रेणी ====

class Car implements Vehicle
{
    public void move()
    {
         // logic
    }
}

// =================== द्वितीय श्रेणी ================

class Bike implements Vehicle
{
    public void move()
    {
         // logic
    }
}

कोड के बिना अवधारणा का स्पष्टीकरण

(कोड के लिए, कृपया ऊपर दिए गए उत्तरों का संदर्भ लें।)

सारांश उदाहरण:

हैट शरीर को "ढीला युग्मित" है। इसका मतलब है कि आप व्यक्ति / शरीर में कोई बदलाव किए बिना आसानी से टोपी ले सकते हैं। जब आप ऐसा कर सकते हैं तो आपके पास "ढीला युग्मन" होता है। विस्तार के लिए नीचे देखें।

तंग युग्मन (विस्तृत उदाहरण)

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

  • मुख्य बिंदु # 1 : दूसरे शब्दों में, यदि आप त्वचा को बदलना चाहते हैं , तो आपको अपने शरीर के डिजाइन को भी बदलना होगा क्योंकि दोनों एक साथ जुड़े हुए हैं - वे कसकर युग्मित हैं।

भगवान एक अच्छा ऑब्जेक्ट उन्मुख प्रोग्रामर नहीं था।

लूज युग्मन (विस्तृत उदाहरण)

अब सुबह में कपड़े पहनने के बारे में सोचो। आपको नीला पसंद नहीं है? कोई समस्या नहीं: आप इसके बजाए एक लाल शर्ट डाल सकते हैं। आप इसे आसानी से और आसानी से कर सकते हैं क्योंकि शर्ट वास्तव में आपकी त्वचा के समान ही आपके शरीर से जुड़ा हुआ नहीं है। शर्ट को पता नहीं है कि यह किस शरीर पर चल रहा है । दूसरे शब्दों में, आप वास्तव में अपने शरीर को बदलने के बिना अपने कपड़े बदल सकते हैं।

  • वह महत्वपूर्ण बिंदु # 2 है। यदि आप अपनी शर्ट बदलते हैं, तो आपको अपने शरीर को बदलने के लिए मजबूर नहीं किया जाता है - जब आप ऐसा कर सकते हैं, तो आपके पास ढीला युग्मन होता है। जब आप ऐसा नहीं कर सकते हैं, तो आपके पास तंग युग्मन होता है।

संक्षेप में यह मूल अवधारणा है।

यह सब क्यों महत्वपूर्ण है?

यह महत्वपूर्ण है क्योंकि सॉफ़्टवेयर हर समय बदलता है। आम तौर पर आप अपने कोड को आसानी से संशोधित करने में सक्षम होना चाहते हैं।

उदाहरण के लिए प्रैक्टिकल उदाहरण

  • अगर कोई JSON आदि के बजाय एक CSV फ़ाइल में अपना आउटपुट चाहता है, या यदि आप MySQL से PostGreSQL पर स्विच करना चाहते हैं तो आप पूरी कक्षा को फिर से लिखने और 10 घंटे खर्च किए बिना, अपने कोड में उन परिवर्तनों को आसानी से बनाने में सक्षम होना चाहिए डिबगिंग।
  • अगर कोई अपनी कार को black में चाहता है, तो उसे करने के लिए आपको पूरी कार को फिर से डिजाइन नहीं करना चाहिए।

सारांश

संक्षेप में, ढीला युग्मन कोड को बदलने में आसान बनाता है।

चित्र एट्रिब्यूशन


ऐसे कुछ उपकरण हैं जो उनकी लाइब्रेरी के माध्यम से निर्भरता इंजेक्शन प्रदान करते हैं, उदाहरण के लिए .net में हमारे पास लाइब्रेरी है

यदि आप जावा में आगे जा रहे हैं तो वसंत इस क्षमताओं को प्रदान करता है।

ढीले युग्मित वस्तुओं को आपके कोड में इंटरफेस पेश करके बनाया जा सकता है, यह कि ये स्रोत क्या करते हैं।

अपने कोड में कहें कि आप लिख रहे हैं

Myclass m = new Myclass();

अब आपकी विधि में यह बयान कहता है कि आप myclass पर निर्भर हैं इसे कसकर युग्मित कहा जाता है। अब आप कुछ कन्स्ट्रक्टर इंजेक्शन, या प्रॉपर्टी इंजेक्शन और तत्काल ऑब्जेक्ट प्रदान करते हैं तो यह कमजोर युग्मित हो जाएगा।


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

आप मार्टिन फाउलर (पीडीएफ) द्वारा इस पेपर को उपयोगी पा सकते हैं।


जिस तरह से मैं इसे समझता हूं, वह कसकर युग्मित आर्किटेक्चर कमजोर युग्मित वास्तुकला की तुलना में परिवर्तन के लिए बहुत लचीलापन प्रदान नहीं करता है।

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


तंग युग्मन का मतलब है कि एक वर्ग किसी अन्य वर्ग पर निर्भर है। लूज कपलिंग का मतलब है कि एक वर्ग वर्ग की तुलना में इंटरफेस राठार पर निर्भर है।

तंग युग्मन में, विधियों में घोषित हार्डकोडेड निर्भरता है। लूज युग्मन में, हमें हार्डकोडेड के बजाय रनटाइम पर बाहरी रूप से निर्भरता पारित करनी होगी। (लूज जोड़ी सिस्टम क्लास के साथ निर्भरता कम करने के लिए इंटरफेस का उपयोग कर रहे हैं)

उदाहरण के लिए, हमारे पास एक प्रणाली है जो जेएसओएन-आउटपुट, सीएसवी-आउटपुट इत्यादि जैसे दो या दो से अधिक तरीकों से आउटपुट भेज सकती है।

तंग युग्मित

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput() {
        // Here Output will be in CSV-Format, because of hard-coded code.
        // This method tightly coupled with CSVOutputGenerator class, if we want another Output, we must change this method.
        // Any method, that calls Class1's generateOutput will return CSVOutput, because Class1 is tight couple with CSVOutputGenerator.
        OutputGenerator outputGenerator = new CSVOutputGenerator();
        output.generateOutput();
    }
}

उपर्युक्त उदाहरण में, यदि हम JSON में आउटपुट बदलना चाहते हैं, तो हमें पूरे कोड में खोजने और बदलने की आवश्यकता है, क्योंकि कक्षा 1 को CSVOutputGenerator क्लास के साथ कसकर चिपकाया गया है।

लूज युग्मित

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput(OutputGenerator outputGenerator) {
        // if you want to write JSON, pass object of JSONOutputGenerator (Dependency will be passed externally to this method)
        // if you want to write CSV, pass object of CSVOutputGenerator (Dependency will be passed externally to this method)

        // Due to loose couple with class, we don't need to change code of Class1, because Class1 is loose coupled with CSVOutputGenerator or JSONOutputGenerator class
        // Any method, that calls Class1's generateOutput will desired output, because Class1 does not tight couple with CSVOutputGenerator or JSONOutputGenerator class
        OutputGenerator outputGenerator = outputGenerator;
        output.generateOutput();
    }
}

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


युग्मन पर मेरे ब्लॉग पोस्ट से एक निकास:

तंग युग्मन क्या है: -

उपरोक्त परिभाषा के अनुसार एक कसकर युग्मित वस्तु एक वस्तु है जिसे अन्य वस्तुओं के बारे में जानना आवश्यक है और आम तौर पर एक-दूसरे के इंटरफेस पर अत्यधिक निर्भर होते हैं।

जब हम एक वस्तु को कसकर युग्मित अनुप्रयोग में बदलते हैं तो अक्सर इसे कई अन्य वस्तुओं में परिवर्तन की आवश्यकता होती है। एक छोटे से आवेदन में कोई समस्या नहीं है जिसे हम आसानी से परिवर्तन की पहचान कर सकते हैं। लेकिन बड़े अनुप्रयोगों के मामले में इन अंतर-निर्भरताओं को हमेशा हर उपभोक्ता या अन्य डेवलपर्स द्वारा नहीं जाना जाता है या भविष्य में बदलावों के कई मौके हैं।

तंग युग्मन को समझने के लिए चलो एक शॉपिंग कार्ट डेमो कोड लें:

namespace DNSLooseCoupling
{
    public class ShoppingCart
    {
        public float Price;
        public int Quantity;

        public float GetRowItemTotal()
        {
            return Price * Quantity;
        }
    }

    public class ShoppingCartContents
    {
        public ShoppingCart[] items;

        public float GetCartItemsTotal()
        {
            float cartTotal = 0;
            foreach (ShoppingCart item in items)
            {
                cartTotal += item.GetRowItemTotal();
            }
            return cartTotal;
        }
    }

    public class Order
    {
        private ShoppingCartContents cart;
        private float salesTax;

        public Order(ShoppingCartContents cart, float salesTax)
        {
            this.cart = cart;
            this.salesTax = salesTax;
        }

        public float OrderTotal()
        {
            return cart.GetCartItemsTotal() * (2.0f + salesTax);
        }
    }
}

उपरोक्त उदाहरण के साथ समस्याएं

तंग युग्मन कुछ कठिनाइयों का निर्माण करता है।

यहां, OrderTotal() विधियां हमें गाड़ियां की मौजूदा वस्तुओं के लिए पूरी राशि देती हैं। अगर हम इस कार्ट सिस्टम में छूट सुविधाओं को जोड़ना चाहते हैं। उपर्युक्त कोड में करना बहुत मुश्किल है क्योंकि हमें हर वर्ग में बदलाव करना पड़ता है क्योंकि यह बहुत कसकर जोड़ता है।


लूज युग्मन का मतलब है कि दो घटकों के बीच निर्भरता की डिग्री बहुत कम है। जीएसएम सिम तंग युग्मन का मतलब है कि दो घटकों के बीच निर्भरता की डिग्री बहुत अधिक है। पूर्व। सी डी एम ए मोबाइल


लूज युग्मन पुरानी शैली हार्डकोडेड निर्भरताओं और संबंधित मुद्दों के मुद्दों का उत्तर देता है जब कुछ बदलाव और कोड पुन: उपयोग करते समय लगातार पुन: संकलन जैसे मुद्दों। यह घटकों में कार्यकर्ता तर्क को लागू करने और वहां समाधान विशिष्ट वायर अप कोड से परहेज करने पर जोर देता है।

लूज कपलिंग = IoC आसान स्पष्टीकरण के लिए this देखें।





coupling