In this fifth part of the Software Design Patterns blog series I’ll talk about a pattern that probably most of us have heard of or even used before but that we haven’t had the opportunity to build, I’m talking about the Adapter Pattern.
The Adapter pattern acts as a bridge between two incompatible classes by “adapting” the functionality of one class into the other via an interface. One of the most popular examples of the Adapter Pattern is how different programming languages uses Adapter classes to access a database, it’s very common to se
PgSqlDataAdapter, etc, what these adapters are doing is creating a bridge or “adapting” into the specificities of each database engine so you don’t have to worry about those minor details or worse having to create your own adapters.
Now let’s look at an example with an electrical socket analogy.
class EuropeanSocketInterface: def voltage(self): pass def live(self): pass def neutral(self): pass def earth(self): pass # Adaptee class Socket(EuropeanSocketInterface): def voltage(self): return 230 def live(self): return 1 def neutral(self): return -1 def earth(self): return 0 # Target interface class USASocketInterface: def voltage(self): pass def live(self): pass def neutral(self): pass # The Adapter class Adapter(USASocketInterface): __socket = None def __init__(self, socket): self.__socket = socket def voltage(self): return 110 def live(self): return self.__socket.live() def neutral(self): return self.__socket.neutral() # Client class ElectricKettle: __power = None def __init__(self, power): self.__power = power def boil(self): if self.__power.voltage() > 110: print("Halt and catch fire!") else: if self.__power.live() == 1 and self.__power.neutral() == -1: print("Coffee time!") else: print("No power.")
In this example we have a socket which is European type (
EuropeanSocketInterface) and we have a Kettle which have an electrical plug of the type we use in the US (
USASocketInterface), now in order for us to be able to plug the Kettle in the European style socket we need to use an adapter (
Adapter) that will use the
USASocketInterface, if you check both socket interfaces the European and the USA we see that both have similar interface (
Now let’s see the example.
socket = Socket() adapter = Adapter(socket) kettle = ElectricKettle(adapter) kettle.boil()
The output being
Here you can see the
ElectricKettle class using the adapter (
Adapter) to adapt to the European style socket. And if you check the
Adapter we can see that we’re really only overriding the value of
110 which is what the
ElectricKettle use, in the case that it’s higher than
110 it will
"Halt and catch fire!", on the other hand if everything else is correct it’s going to be
"Coffee time!" or
And this is it for the Adapter pattern hope it’s clear enough, if you have any comments or questions feel free to reach out on twitter at @fcastellanos.