Python Design Patterns - Adaptador

O padrão do adaptador funciona como uma ponte entre duas interfaces incompatíveis. Esse tipo de padrão de design vem sob o padrão estrutural, pois esse padrão combina a capacidade de duas interfaces independentes.

Este padrão envolve uma única classe, que é responsável por unir funcionalidades de interfaces independentes ou incompatíveis. Um exemplo da vida real poderia ser o caso de um leitor de cartão, que atua como um adaptador entre o cartão de memória e um laptop. Você conecta o cartão de memória no leitor de cartão e o leitor de cartão no laptop para que o cartão de memória possa ser lido no laptop.

O padrão de design do adaptador ajuda a trabalhar as classes juntas. Ele converte a interface de uma classe em outra interface com base no requisito. O padrão inclui uma especiação, um polimorfismo que nomeia um nome e várias formas. Digamos que uma classe de forma possa ser usada de acordo com os requisitos reunidos.

Existem dois tipos de padrão de adaptador -

Padrão Adaptador de Objeto

Este padrão de design depende da implementação do objeto. Conseqüentemente, é chamado de Padrão Adaptador de Objetos.

Padrão Adaptador de Classe

Esta é uma maneira alternativa de implementar o padrão de design do adaptador. O padrão pode ser implementado usando várias heranças.

Como implementar o padrão do adaptador?

Vamos agora ver como implementar o padrão do adaptador.

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 "Kettle on fire!"
      else:
         if self.__power.live() == 1 and \
            self.__power.neutral() == -1:
            print "Coffee time!"
         else:
            print "No power."

def main():
   # Plug in
   socket = Socket()
   adapter = Adapter(socket)
   kettle = ElectricKettle(adapter)
	
   # Make coffee
   kettle.boil()
	
   return 0
	
if __name__ == "__main__":
   main()

Resultado

O programa acima gera a seguinte saída -

Explicação

O código inclui interface do adaptador com vários parâmetros e atributos. Inclui o Adaptee junto com a interface de destino que implementa todos os atributos e exibe a saída como visível.