"Hej, Amigo! Idag ska jag berätta vad en " adapter " är. Jag hoppas att du efter att ha lärt dig om detta ämne kommer att ha en mycket bättre förståelse för in-/utgångsströmmar."

Adaptrar - 1

Föreställ dig att ditt program använder två ramverk skrivna av andra programmerare/företag. Båda ramverken är mycket bra och använder OOP-principer: abstraktion, polymorfism, inkapsling. Tillsammans täcker de nästan helt vad ditt program behöver göra. Du har en enkel uppgift kvar. Du måste skicka objekt skapade av ett ramverk till det andra ramverket. Men båda ramarna är helt olika och "vet inte om varandra", dvs de har inga klasser gemensamma. Du måste på något sätt konvertera objekten i en ram till objekt i den andra.

Denna uppgift kan lösas vackert genom att tillämpa " adapter "-tekniken (designmönster):

Java university
Java-kod Beskrivning 
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
}
 Detta återspeglar adapterns designmönster.

Grundtanken är att klassen MyClass konverterar (anpassar) det ena gränssnittet till det andra.

"Kan du ge mig ett mer specifikt exempel?"

"OK. Låt oss säga att varje ramverk har sitt eget unika "list"-gränssnitt. De kan se ut ungefär så här:"

Java-kod Beskrivning 
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);
}
 Kod från det första ( Alpha ) ramverket

AlphaList är ett av gränssnitten som gör att ramkoden kan interagera med koden som använder ramverket.

 
class AlphaListManager
{
 public static AlphaList createList()
 {
  //some code to create an object
 }
}
 AlphaList Manager AlphaListManager är en klass i ramverket. Dess createList-metod skapar ett AlphaList- objekt 
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
 }
}
 Kod från det andra ( Beta ) ramverket.

BetaList är ett av gränssnitten som gör att ramkoden kan interagera med koden som använder ramverket.

BetaSaveManager är en klass i ramverket. Dess saveList- metod sparar ett BetaList- objekt

 
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);
   }
  }
 }
}
 Klassen «Adapter» som konverterar från AlphaList -gränssnittet till BetaList -gränssnittet

ListAdapter - klassen implementerar BetaList- gränssnittet från det andra ramverket.

När någon anropar dessa metoder, "vidarebefordrar" klasskoden anropen till listvariabeln, som är en AlphaList från det första ramverket.

Ett AlphaList- objekt skickas till ListAdapter -konstruktorn

Metoden setSize fungerar enligt följande regler: om storleken på listan måste ökas, lägg till tomma (null) objekt. Om storleken på listan behöver minskas, radera objekt i slutet.

 
public static void main(String[] args)
{
 AlphaList listAlpha = AlphaListManager.createList();
 BetaList listBeta = new ListAdapter(listAlpha);
 BetaSaveManager.saveList(listBeta);
}
 Ett exempel på hur det kan användas

"Jag gillade ditt sista exempel mest av allt. Mycket kortfattat och begripligt."