O que é o padrão 'Comando' (Command)?

Padrão de comportamento de design que transforma uma solicitação em um objeto separado que contém todas as informações sobre a solicitação. Isso permite parametrizar métodos de objetos com diferentes solicitações, colocá-las em fila ou registrá-las, além de suportar o cancelamento de operações.

Elementos principais do padrão:

• Comando (Command): Classe abstrata ou interface que declara um método para executar a solicitação.

  // Interface de comando
  class Command:
      def execute(self):
          pass
  

• Comando Concreto (Concrete Command): Implementa a interface Command e vincula o receptor à ação. Define um conjunto de ações que devem ser realizadas no receptor.

  // Comando concreto para ligar a luz
  class LightOnCommand(Command):
      def __init__(self, light):
          self._light = light # Receptor
  
      def execute(self):
          self._light.on()
  

• Receptor (Receiver): Classe que sabe como realizar o trabalho real. No nosso exemplo, é Light.

  // Receptor - objeto sobre o qual as ações são realizadas
  class Light:
      def on(self):
          print("Luz ligada")
  
      def off(self):
          print("Luz desligada")
  

• Invocador (Invoker): Objeto que solicita ao comando a execução da ação. Não conhece o comando ou receptor específico.

  // Invocador - chama o comando
  class RemoteControl:
      def set_command(self, command):
          self._command = command
  
      def press_button(self):
          self._command.execute()
  

• Cliente (Client): Cria objetos Comando Concreto e os vincula ao Receptor. Depois, passa o comando ao Invoker.

  // Código do cliente
  if __name__ == "__main__":
      light = Light() # Receptor
      light_on_command = LightOnCommand(light) # Comando concreto
  
      remote = RemoteControl() # Invocador
      remote.set_command(light_on_command) # Passa o comando ao invocador
  
      remote.press_button() # Invocador chama o comando
  

Vantagens:

• Separa o invocador e o receptor do comando.
• Permite parametrizar o invocador com diferentes comandos.
• Facilita a implementação de desfazer/repetir operações (ao salvar o histórico de comandos).
• Permite construir filas de comandos e registrar sua execução.

Desvantagens:

• Pode levar a um grande número de classes se houver muitos comandos.