Adapter pattern

Overview

Definition

Usage

Structure

UML class diagram

Object adapter pattern

Class adapter pattern

A further form of runtime adapter pattern

Motivation from compile time solution

classB.setStringData(classA.getStringData());

publicclass Format1ClassAextendsClassA{
@Override
publicStringgetStringData(){
returnformat(toString());
}
}

Run-time adapter solution

1. Define an intermediary "provider" interface, and write an implementation of that provider interface that wraps the source of the data, ClassA in this example, and outputs the data formatted as appropriate:

   publicinterface StringProvider{
   publicStringgetStringData();
   }
   publicclass ClassAFormat1implementsStringProvider{
   privateClassAclassA=null;
   publicClassAFormat1(finalClassAa){
   classA=a;
   }
   publicStringgetStringData(){
   returnformat(classA.getStringData());
   }
   privateStringformat(finalStringsourceValue){
   // Manipulate the source string into a format required 
   // by the object needing the source object's data
   returnsourceValue.trim();
   }
   }
   

2. Write an adapter class that returns the specific implementation of the provider:

   publicclass ClassAFormat1AdapterextendsAdapter{
   publicObjectadapt(finalObjectanObject){
   returnnewClassAFormat1((ClassA)anObject);
   }
   }
   

3. Register the adapter with a global registry, so that the adapter can be looked up at runtime:

   AdapterFactory.getInstance().registerAdapter(ClassA.class,ClassAFormat1Adapter.class,"format1");
   

4. In code, when wishing to transfer data from ClassA to ClassB, write:

   Adapteradapter=AdapterFactory.getInstance()
   .getAdapterFromTo(ClassA.class,StringProvider.class,"format1");
   StringProviderprovider=(StringProvider)adapter.adapt(classA);
   Stringstring=provider.getStringData();
   classB.setStringData(string);
   

   or more concisely:

   classB.setStringData(((StringProvider)AdapterFactory.getInstance()
   .getAdapterFromTo(ClassA.class,StringProvider.class,"format1")
   .adapt(classA))
   .getStringData()
   );
   

5. The advantage can be seen in that, if it is desired to transfer the data in a second format, then look up the different adapter/provider:

   Adapteradapter=AdapterFactory.getInstance()
   .getAdapterFromTo(ClassA.class,StringProvider.class,"format2");
   

6. And if it is desired to output the data from ClassA as, say, image data in ClassC:

   Adapteradapter=AdapterFactory.getInstance()
   .getAdapterFromTo(ClassA.class,ImageProvider.class,"format2");
   ImageProviderprovider=(ImageProvider)adapter.adapt(classA);
   classC.setImage(provider.getImage());
   

7. In this way, the use of adapters and providers allows multiple "views" by ClassB and ClassC into ClassA without having to alter the class hierarchy. In general, it permits a mechanism for arbitrary data flows between objects that can be retrofitted to an existing object hierarchy.

Implementation of the adapter pattern

Java

interface ILightningPhone{
voidrecharge();
voiduseLightning();
}
interface IMicroUsbPhone{
voidrecharge();
voiduseMicroUsb();
}
class IphoneimplementsILightningPhone{
privatebooleanconnector;
@Override
publicvoiduseLightning(){
connector=true;
System.out.println("Lightning connected");
}
@Override
publicvoidrecharge(){
if(connector){
System.out.println("Recharge started");
System.out.println("Recharge finished");
}else{
System.out.println("Connect Lightning first");
}
}
}
class AndroidimplementsIMicroUsbPhone{
privatebooleanconnector;
@Override
publicvoiduseMicroUsb(){
connector=true;
System.out.println("MicroUsb connected");
}
@Override
publicvoidrecharge(){
if(connector){
System.out.println("Recharge started");
System.out.println("Recharge finished");
}else{
System.out.println("Connect MicroUsb first");
}
}
}
/* exposing the target interface while wrapping source object */
class LightningToMicroUsbAdapterimplementsIMicroUsbPhone{
privatefinalILightningPhonelightningPhone;
publicLightningToMicroUsbAdapter(ILightningPhonelightningPhone){
this.lightningPhone=lightningPhone;
}
@Override
publicvoiduseMicroUsb(){
System.out.println("MicroUsb connected");
lightningPhone.useLightning();
}
@Override
publicvoidrecharge(){
lightningPhone.recharge();
}
}
publicclass AdapterDemo{
staticvoidrechargeMicroUsbPhone(IMicroUsbPhonephone){
phone.useMicroUsb();
phone.recharge();
}
staticvoidrechargeLightningPhone(ILightningPhonephone){
phone.useLightning();
phone.recharge();
}
publicstaticvoidmain(String[]args){
Androidandroid=newAndroid();
IphoneiPhone=newIphone();
System.out.println("Recharging android with MicroUsb");
rechargeMicroUsbPhone(android);
System.out.println("Recharging iPhone with Lightning");
rechargeLightningPhone(iPhone);
System.out.println("Recharging iPhone with MicroUsb");
rechargeMicroUsbPhone(newLightningToMicroUsbAdapter(iPhone));
}
}

Python

"""
Adapter pattern example.
"""
fromabcimport ABCMeta, abstractmethod
fromtypingimport Dict, List, NoReturn
RECHARGE: List[str] = ["Recharge started.", "Recharge finished."]
POWER_ADAPTERS: Dict[str, str] = {"Android": "MicroUSB", "iPhone": "Lightning"}
CONNECTED_MSG: str = "{} connected."
CONNECT_FIRST_MSG: str = "Connect {} first."
classRechargeTemplate(metaclass = ABCMeta):
 @abstractmethod
 defrecharge(self) -> NoReturn:
 raise NotImplementedError("You should implement this.")
classFormatIPhone(RechargeTemplate):
 @abstractmethod
 defuse_lightning(self) -> NoReturn:
 raise NotImplementedError("You should implement this.")
classFormatAndroid(RechargeTemplate):
 @abstractmethod
 defuse_micro_usb(self) -> NoReturn:
 raise NotImplementedError("You should implement this.")
classIPhone(FormatIPhone):
 __name__: str = "iPhone"
 def__init__(self):
 self.connector: bool = False
 defuse_lightning(self) -> None:
 self.connector = True
 print(CONNECTED_MSG.format(POWER_ADAPTERS[self.__name__]))
 defrecharge(self) -> None:
 if self.connector:
 for state in RECHARGE:
 print(state)
 else:
 print(CONNECT_FIRST_MSG.format(POWER_ADAPTERS[self.__name__]))
classAndroid(FormatAndroid):
 __name__: str = "Android"
 def__init__(self) -> None:
 self.connector: bool = False
 defuse_micro_usb(self) -> None:
 self.connector = True
 print(CONNECTED_MSG.format(POWER_ADAPTERS[self.__name__]))
 defrecharge(self) -> None:
 if self.connector:
 for state in RECHARGE:
 print(state)
 else:
 print(CONNECT_FIRST_MSG.format(POWER_ADAPTERS[self.__name__]))
classIPhoneAdapter(FormatAndroid):
 def__init__(self, mobile: FormatAndroid) -> None:
 self.mobile: FormatAndroid = mobile
 defrecharge(self) -> None:
 self.mobile.recharge()
 defuse_micro_usb(self) -> None:
 print(CONNECTED_MSG.format(POWER_ADAPTERS["Android"]))
 self.mobile.use_lightning()
classAndroidRecharger:
 def__init__(self) -> None:
 self.phone: Android = Android()
 self.phone.use_micro_usb()
 self.phone.recharge()
classIPhoneMicroUSBRecharger:
 def__init__(self) -> None:
 self.phone: IPhone = IPhone()
 self.phone_adapter: IPhoneAdapter = IPhoneAdapter(self.phone)
 self.phone_adapter.use_micro_usb()
 self.phone_adapter.recharge()
classIPhoneRecharger:
 def__init__(self) -> None:
 self.phone: IPhone = IPhone()
 self.phone.use_lightning()
 self.phone.recharge()
print("Recharging Android with MicroUSB recharger.")
AndroidRecharger()
print()
print("Recharging iPhone with MicroUSB using adapter pattern.")
IPhoneMicroUSBRecharger()
print()
print("Recharging iPhone with iPhone recharger.")
IPhoneRecharger()

C#

publicinterfaceILightningPhone
{
voidConnectLightning();
voidRecharge();
}
publicinterfaceIUsbPhone
{
voidConnectUsb();
voidRecharge();
}
publicsealedclassAndroidPhone:IUsbPhone
{
privateboolisConnected;
publicvoidConnectUsb()
{
this.isConnected=true;
Console.WriteLine("Android phone connected.");
}
publicvoidRecharge()
{
if(this.isConnected)
{
Console.WriteLine("Android phone recharging.");
}
else
{
Console.WriteLine("Connect the USB cable first.");
}
}
}
publicsealedclassApplePhone:ILightningPhone
{
privateboolisConnected;
publicvoidConnectLightning()
{
this.isConnected=true;
Console.WriteLine("Apple phone connected.");
}
publicvoidRecharge()
{
if(this.isConnected)
{
Console.WriteLine("Apple phone recharging.");
}
else
{
Console.WrizteLine("Connect the Lightning cable first.");
}
}
}
publicsealedclassLightningToUsbAdapter:IUsbPhone
{
privatereadonlyILightningPhonelightningPhone;
privateboolisConnected;
publicLightningToUsbAdapter(ILightningPhonelightningPhone)
{
this.lightningPhone=lightningPhone;
}
publicvoidConnectUsb()
{
this.lightningPhone.ConnectLightning();
}
publicvoidRecharge()
{
this.lightningPhone.Recharge();
}
}
publicvoidMain()
{
ILightningPhoneapplePhone=newApplePhone();
IUsbPhoneadapterCable=newLightningToUsbAdapter(applePhone);
adapterCable.ConnectUsb();
adapterCable.Recharge();
}

Apple phone connected.
Apple phone recharging.

See also

References