Padrão Strategy

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy — lição 93 de 110.

O padrão Strategy permite que você defina uma família de algoritmos, encapsule cada um em sua própria classe e os torne intercambiáveis em tempo de execução. Em vez de codificar rigidamente o comportamento em uma classe, você injeta o comportamento por meio de uma interface, permitindo trocar as estratégias sem modificar a classe que as utiliza.

Considere um sistema de pagamento onde você deseja oferecer suporte a diferentes métodos de pagamento. Em vez de usar condicionais para lidar com cada método, você define uma interface de estratégia e cria implementações concretas:

abstract class PaymentStrategy {
  void pay(double amount);
}

class CreditCardPayment implements PaymentStrategy {
  @override
  void pay(double amount) => print('Paid \$amount with Credit Card');
}

class PayPalPayment implements PaymentStrategy {
  @override
  void pay(double amount) => print('Paid \$amount with PayPal');
}

class ShoppingCart {
  PaymentStrategy _paymentStrategy;

  ShoppingCart(this._paymentStrategy);

  void setPaymentStrategy(PaymentStrategy strategy) {
    _paymentStrategy = strategy;
  }

  void checkout(double total) {
    _paymentStrategy.pay(total);
  }
}

void main() {
  var cart = ShoppingCart(CreditCardPayment());
  cart.checkout(99.99);  // Paid $99.99 with Credit Card

  cart.setPaymentStrategy(PayPalPayment());
  cart.checkout(49.99);  // Paid $49.99 with PayPal
}

O ShoppingCart não sabe nem se importa com o funcionamento do pagamento - ele apenas delega para qualquer estratégia que esteja definida no momento. Você pode adicionar novos métodos de pagamento criando novas classes de estratégia sem tocar no código do carrinho. Este padrão é ideal quando você tem várias maneiras de realizar uma ação e deseja selecionar ou alternar entre elas dinamicamente.

Desafio

Fácil

Vamos construir um sistema de formatação de texto usando o padrão Strategy! Você criará um sistema onde diferentes estratégias de formatação podem ser aplicadas ao texto, permitindo que os usuários alternem entre formatos dinamicamente sem alterar o processador de texto principal.

Você organizará seu código em dois arquivos:

formatting_strategies.dart: Crie seu sistema de estratégia aqui. Defina uma classe abstrata FormattingStrategy com um método String format(String text). Em seguida, implemente três estratégias concretas:
- UppercaseStrategy - converte o texto para todas as letras maiúsculas
- LowercaseStrategy - converte o texto para todas as letras minúsculas
- TitleCaseStrategy - coloca a primeira letra de cada palavra em maiúscula (divida por espaços, coloque o primeiro caractere de cada palavra em maiúscula e o restante em minúscula)
Crie também uma classe TextProcessor que contém uma FormattingStrategy. Ela deve ter um construtor que aceite uma estratégia inicial, um método setStrategy() para alterar a estratégia em tempo de execução e um método process(String text) que aplique a estratégia atual e retorne o resultado formatado.
main.dart: Importe suas estratégias de formatação e demonstre como o padrão Strategy permite a alternância dinâmica de comportamento. Crie um TextProcessor começando com a UppercaseStrategy. Processe o texto 'hello world' e imprima o resultado. Em seguida, mude para LowercaseStrategy, processe 'HELLO WORLD' e imprima. Por fim, mude para TitleCaseStrategy, processe 'the quick brown fox' e imprima o resultado.

Isso demonstra o poder do padrão Strategy - seu TextProcessor não precisa conhecer os detalhes de como a formatação funciona. Ele simplesmente delega para qualquer estratégia que esteja definida no momento, facilitando a adição de novas opções de formatação sem modificar o processador!

Saída esperada:

HELLO WORLD
hello world
The Quick Brown Fox

Folha de consulta

O padrão Strategy define uma família de algoritmos, encapsula cada um em sua própria classe e os torna intercambiáveis em tempo de execução. Em vez de codificar o comportamento de forma rígida, você o injeta por meio de uma interface.

Defina uma interface de estratégia:

abstract class PaymentStrategy {
  void pay(double amount);
}

Crie implementações de estratégia concretas:

class CreditCardPayment implements PaymentStrategy {
  @override
  void pay(double amount) => print('Paid \$amount with Credit Card');
}

class PayPalPayment implements PaymentStrategy {
  @override
  void pay(double amount) => print('Paid \$amount with PayPal');
}

Crie uma classe de contexto que utiliza a estratégia:

class ShoppingCart {
  PaymentStrategy _paymentStrategy;

  ShoppingCart(this._paymentStrategy);

  void setPaymentStrategy(PaymentStrategy strategy) {
    _paymentStrategy = strategy;
  }

  void checkout(double total) {
    _paymentStrategy.pay(total);
  }
}

Use o padrão injetando e alternando estratégias:

var cart = ShoppingCart(CreditCardPayment());
cart.checkout(99.99);  // Pago $99.99 com Cartão de Crédito

cart.setPaymentStrategy(PayPalPayment());
cart.checkout(49.99);  // Pago $49.99 com PayPal

A classe de contexto delega o comportamento para a estratégia sem conhecer os detalhes da implementação. Adicione novas estratégias criando novas classes sem modificar o código existente.

Experimente você mesmo

import 'formatting_strategies.dart';

void main() {
  // TODO: Crie um TextProcessor começando com UppercaseStrategy
  
  // TODO: Processe o texto 'hello world' e imprima o resultado
  
  // TODO: Mude para LowercaseStrategy
  
  // TODO: Processe 'HELLO WORLD' e imprima o resultado
  
  // TODO: Mude para TitleCaseStrategy
  
  // TODO: Processe 'the quick brown fox' e imprima o resultado
}