ब्रिज पैटर्न और एडाप्टर पैटर्न

Question

के बीच अंतर ब्रिज और एडाप्टर पैटर्न के बीच क्या अंतर है? मैं प्रत्येक पैटर्न का उपयोग कहां कर सकता हूं?

Answer 1

"एडाप्टर चीजें काम के बाद वे तैयार किया गया है कर रहे हैं बनाता है;। ब्रिज उन्हें वे कर रहे हैं से पहले काम करता है [GOF, p219]"

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

public class SuperWeaponsArray { 
    /*...*/ 

    public void destroyWorld() { 
    for (Weapon w : armedWeapons) { 
     w.fire(); 
    } 
    } 
} 

ग्रेट। सिवाय इसके कि हम महसूस करते हैं कि हमारे शस्त्रागार में परमाणु उपकरण है जो हथियार इंटरफेस में रूपांतरण की भविष्यवाणी करता है। लेकिन हम वास्तव में इसे यहां काम करना पसंद करेंगे ... तो हम क्या करते हैं ... इसे घुमाओ!

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

---

ब्रिज पैटर्न कुछ आप सामने लागू है - यदि आप जानते हैं कि आप दो ओर्थोगोनल पदानुक्रम है, यह इंटरफेस और इस तरह से कार्यान्वयन है कि आप एक पागल संख्या नहीं मिलता है दसगुणा एक तरीका प्रदान करता कक्षाओं का मान लीजिए कि आप करते हैं:

MemoryMappedFile और DirectReadFile फ़ाइल प्रकार के ऑब्जेक्ट ने। मान लीजिए कि आप विभिन्न स्रोतों से फ़ाइलों को पढ़ने में सक्षम होना चाहते हैं (शायद लिनक्स बनाम विंडोज कार्यान्वयन, आदि)।

MemoryMappedWindowsFile MemoryMappedLinuxFile DirectReadWindowsFile DirectReadLinuxFile

Answer 2

http://en.wikipedia.org/wiki/Adapter_pattern

एडाप्टर पैटर्न एक नए सिस्टम या इंटरफेस के साथ काम करने के लिए अपने मौजूदा कोड प्राप्त करने के बारे में अधिक है।

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

http://en.wikipedia.org/wiki/Bridge_pattern

ब्रिज पैटर्न आप संभवतः एक एल्गोरिथ्म या सिस्टम के विकल्प कार्यान्वयन के लिए अनुमति देने के लिए जा रहा है।

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

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

Answer 3

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

Answer 4

एडाप्टर:

1. यह एक संरचनात्मक पैटर्न
2. यह दो असंगत इंटरफेस

यूएमएल आरेख के साथ काम करने के लिए उपयोगी है:dofactory लेख से:

लक्ष्य: डोमेन-विशिष्ट इंटरफेस है कि ग्राहक का उपयोग करता है परिभाषित करता है।

एडाप्टर: लक्ष्य इंटरफेस के लिए इंटरफ़ेस Adaptee adapts।

Adaptee: कि अनुकूल जरूरत है एक मौजूदा इंटरफेस को परिभाषित करता।

ग्राहक: लक्ष्य इंटरफ़ेस के अनुरूप वस्तुओं के साथ सहयोग करता है।

उदाहरण:

वर्ग और आयत दो अलग अलग आकार और हो रही है क्षेत्र() उनमें से प्रत्येक के हैं अलग अलग तरीकों की आवश्यकता है। लेकिन अभी भी कुछ गुणों के रूपांतरण के साथ आयताकार इंटरफेस पर स्क्वायर काम।

public class AdapterDemo{ 
    public static void main(String args[]){ 
     SquareArea s = new SquareArea(4); 
     System.out.println("Square area :"+s.getArea()); 
    } 
} 

class RectangleArea { 
    public int getArea(int length, int width){ 
     return length * width; 
    } 
} 

class SquareArea extends RectangleArea { 

    int length; 
    public SquareArea(int length){ 
     this.length = length; 
    } 
    public int getArea(){ 
     return getArea(length,length); 
    } 
} 

ब्रिज:

1. यह है संरचनात्मक पैटर्न
2. यह इसके कार्यान्वयन से एक अमूर्त अलग करता है और दोनों स्वतंत्र रूप से
3. भिन्न हो सकते हैं यह संभव है क्योंकि संरचना में इस्तेमाल किया गया है विरासत की जगह

संपादित करें: (@quasoft सुझाव के अनुसार)

आपके पास इस पैटर्न में चार घटक हैं।

1. अमूर्त: यह एक इंटरफेस को परिभाषित करता

2. RefinedAbstraction: यह लागू करता अमूर्त:

3. implementor: यह लागू करने के लिए एक इंटरफेस को परिभाषित करता

4. ConcreteImpleme ntor: यह कार्यान्वयन इंटरफ़ेस लागू करता है।

कोड स्निपेट:

Gear gear = new ManualGear(); 
Vehicle vehicle = new Car(gear); 
vehicle.addGear(); 

gear = new AutoGear(); 
vehicle = new Car(gear); 
vehicle.addGear(); 

संबंधित पोस्ट:

When do you use the Bridge Pattern? How is it different from Adapter pattern?

कुंजी मतभेद:sourcemaking से लेख

1. एडाप्टर डिजाइन किए जाने के बाद चीजें काम करता है; पुल उन्हें पहले काम करता है।
2. ब्रिज को अबास्ट्रक्शन और कार्यान्वयन को स्वतंत्र रूप से अलग करने के लिए ऊपर-सामने डिज़ाइन किया गया है। असंबद्ध वर्गों को एक साथ काम करने के लिए एडाप्टर को फिर से लगाया जाता है।

Answer 5

मान लीजिए कि आपके पास एक (जेनेरिक/अमूर्त) ड्राइंग कार्यक्षमता और एक सर्कल जो आकार लागू करता है, के साथ एक सार आकार वर्ग है। ब्रिज पैटर्न केवल कार्यान्वयन (सर्किल में ड्राइंग) और जेनेरिक/सारणित कार्यक्षमता (आकार वर्ग में ड्राइंग) को कम करने के लिए दो-तरफा अमूर्त दृष्टिकोण है।

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

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

Answer 6

ब्रिज एडाप्टर में सुधार हुआ है। ब्रिज में एडाप्टर शामिल है और इसमें अतिरिक्त लचीलापन शामिल है।

 Adapter | Bridge 
    -----------|--------------- 
    Target  | Abstraction 
    -----------|--------------- 
       | RefinedAbstraction 
       | 
       | This element is Bridge specific. If there is a group of 
       | implementations that share the same logic, the logic can be placed here. 
       | For example, all cars split into two large groups: manual and auto. 
       | So, there will be two RefinedAbstraction classes. 
    -----------|--------------- 
    Adapter | Implementor 
    -----------|--------------- 
    Adaptee | ConcreteImplementor