"हैलो, अमीगो! आज मैं आपको बताऊंगा कि वास्तव में एक « एडाप्टर » क्या है। मुझे उम्मीद है कि इस विषय के बारे में जानने के बाद आपको इनपुट/आउटपुट स्ट्रीम की बेहतर समझ होगी।"

एडेप्टर - 1

कल्पना कीजिए कि आपका प्रोग्राम अन्य प्रोग्रामर/कंपनियों द्वारा लिखे गए दो ढांचे का उपयोग करता है। दोनों ढांचे बहुत अच्छे हैं और ओओपी सिद्धांतों का उपयोग करते हैं: अमूर्तता, बहुरूपता, encapsulation। साथ में, वे लगभग पूरी तरह से कवर करते हैं कि आपके कार्यक्रम को क्या करने की आवश्यकता है। आप एक साधारण कार्य के साथ रह गए हैं। आपको एक ढांचे द्वारा बनाई गई वस्तुओं को दूसरे ढांचे में पास करने की जरूरत है। लेकिन दोनों ढांचे पूरी तरह से अलग हैं और "एक दूसरे के बारे में नहीं जानते", यानी उनके पास कोई वर्ग नहीं है। आपको किसी तरह एक ढांचे की वस्तुओं को दूसरे की वस्तुओं में बदलने की जरूरत है।

« एडाप्टर » तकनीक (डिजाइन पैटर्न) को लागू करके इस कार्य को खूबसूरती से हल किया जा सकता है :

जावा कोड विवरण
class MyClass implements Interface2
{
 private Interface1 object;
 MyClass(Interface1 object)
 {
  this.object = object;
 }
// This is where we put the Interface2 methods 
// that call Interface1 methods
}
यह एडेप्टर डिज़ाइन पैटर्न को दर्शाता है।

मूल विचार यह है कि MyClass वर्ग एक इंटरफ़ेस को दूसरे में परिवर्तित (अनुकूलित) करता है।

"क्या आप मुझे एक और विशिष्ट उदाहरण दे सकते हैं?"

"ठीक है। मान लीजिए कि प्रत्येक रूपरेखा का अपना विशिष्ट "सूची" इंटरफ़ेस है। वे कुछ इस तरह दिख सकते हैं: "

जावा कोड विवरण
interface AlphaList
{
 void add(int value);
 void insert(int index, int value);
 int get(int index);
 void set(int index, int value);
 int count();
 void remove(int index);
}
पहले ( अल्फा ) ढांचे से कोड

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

class AlphaListManager
{
 public static AlphaList createList()
 {
  //some code to create an object
 }
}
AlphaList Manager AlphaListManager ढांचे में एक वर्ग है। इसका createList मेथड एक AlphaList ऑब्जेक्ट
interface BetaList
{
 int getValue(int index);
 void setValue(int index, int value);
 int getSize();
 void setSize(int newSize);
}
class BetaSaveManager
{
 public static void saveList(BetaList list)
 {
  //some code to save a BetaList object
  //to a file on disk
 }
}
दूसरे ( बीटा ) ढांचे से कोड।

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

BetaSaveManager ढांचे में एक वर्ग है। इसका सेवलिस्ट मेथड एक बीटालिस्ट ऑब्जेक्ट को

class ListAdapter implements BetaList
{
 private AlphaList list;
 ListAdapter(AlphaList list)
 {
  this.list = list;
 }

 int getValue(int index)
 {
  return this.list.get(index);
 }

 void setValue(int index, int value)
 {
  this.list.set(index, value);
 }

 int getSize()
 {
  return this.list.count();
 }

 void setSize(int newSize)
 {
  if (newSize > this.list.count()
  {
   while (this.list.count() < newSize)
  {
   this.list.add(null);
  }
 }
 else if (newSize < this.list.count() {
   while (this.list.count() > newSize)
   {
    list.remove(list.count() - 1);
   }
  }
 }
}
«एडाप्टर» वर्ग जो अल्फालिस्ट इंटरफ़ेस से बीटालिस्ट इंटरफ़ेस में परिवर्तित होता है

लिस्ट एडेप्टर क्लास दूसरे फ्रेमवर्क से बीटालिस्ट इंटरफेस को लागू करता है।

जब कोई इन तरीकों को कॉल करता है, तो क्लास कोड «फॉरवर्ड» लिस्ट वेरिएबल को कॉल करता है, जो कि पहले फ्रेमवर्क से एक अल्फालिस्ट है।

एक AlphaList ऑब्जेक्ट ListAdapter कंस्ट्रक्टर को दिया जाता है

सेटसाइज़ विधि निम्नलिखित नियमों के अनुसार संचालित होती है: यदि सूची का आकार बढ़ाया जाना चाहिए, तो खाली (शून्य) आइटम जोड़ें यदि सूची का आकार कम करने की आवश्यकता है, तो अंत में आइटम हटाएं।

public static void main(String[] args)
{
 AlphaList listAlpha = AlphaListManager.createList();
 BetaList listBeta = new ListAdapter(listAlpha);
 BetaSaveManager.saveList(listBeta);
}
इसका उपयोग कैसे किया जा सकता है इसका एक उदाहरण

"मुझे आपका आखिरी उदाहरण सबसे ज्यादा पसंद आया। बहुत संक्षिप्त और समझने योग्य।"