Padrão Decorator

Parte da seção Object Oriented Programming do Journey de Python da Coddy — lição 51 de 64.

O Padrão Decorator adiciona novas funcionalidades a objetos dinamicamente sem alterar sua estrutura. Ele envolve objetos para estender seu comportamento.

Aqui está um exemplo simples de café:

class Coffee:
    def cost(self):
        return 5
    
    def description(self):
        return "Simple coffee"

Crie decoradores que adicionam funcionalidades ao café:

class MilkDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 2
    
    def description(self):
        return self.coffee.description() + " + Milk"

class SugarDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 1
    
    def description(self):
        return self.coffee.description() + " + Sugar"

Cada decorador envolve outro objeto e adiciona sua própria funcionalidade.

Use decoradores para criar um café personalizado:

# Comece com um café básico
my_coffee = Coffee()
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

# Adicione leite
my_coffee = MilkDecorator(my_coffee)
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

# Adicione açúcar
my_coffee = SugarDecorator(my_coffee)
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

Crie outro exemplo com formatação de texto:

class Text:
    def __init__(self, content):
        self.content = content
    
    def render(self):
        return self.content

class BoldDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<b>{self.text.render()}</b>"

class ItalicDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<i>{self.text.render()}</i>"

# Constrói o texto formatado passo a passo
message = Text("Hello World")
message = BoldDecorator(message)
message = ItalicDecorator(message)

print(message.render())

Saída:

Simple coffee: $5
Simple coffee + Milk: $7
Simple coffee + Milk + Sugar: $8
<i><b>Hello World</b></i>

Ponto Chave: O Padrão Decorator envolve objetos para adicionar novos comportamentos sem alterar o objeto original. Cada decorador mantém uma referência ao objeto envolvido e adiciona sua própria funcionalidade. Isso permite combinar múltiplos decoradores para combinações flexíveis de recursos sem criar muitas subclasses.

Desafio

Médio

Neste desafio, você implementará o padrão de projeto Decorator para criar um sistema flexível de pedidos de café para uma cafeteria. O padrão Decorator permite que o comportamento seja adicionado a objetos individuais dinamicamente, sem afetar o comportamento de outros objetos da mesma classe.

Você está construindo um sistema para uma cafeteria que precisa:

Oferecer vários tipos de bebidas (Espresso, Dark Roast, House Blend, Decaf)
Permitir que os clientes adicionem condimentos (Milk, Mocha, Soy, Whipped Cream) às suas bebidas
Calcular o custo das bebidas com os condimentos adicionados

Complete a classe abstrata Beverage e suas implementações concretas em beverage.py
Implemente a classe abstrata CondimentDecorator e os decoradores concretos em condiment_decorator.py
Implemente cenários de teste em driver.py para verificar sua implementação

Folha de consulta

O Padrão Decorator adiciona novas funcionalidades a objetos dinamicamente sem alterar sua estrutura, envolvendo os objetos para estender seu comportamento.

Estrutura básica com um exemplo de café:

class Coffee:
    def cost(self):
        return 5
    
    def description(self):
        return "Simple coffee"

Crie decoradores que envolvem e estendem a funcionalidade:

class MilkDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 2
    
    def description(self):
        return self.coffee.description() + " + Milk"

class SugarDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 1
    
    def description(self):
        return self.coffee.description() + " + Sugar"

Encadeie decoradores para construir objetos personalizados:

# Comece com um café básico
my_coffee = Coffee()

# Adicione decoradores
my_coffee = MilkDecorator(my_coffee)
my_coffee = SugarDecorator(my_coffee)

print(f"{my_coffee.description()}: ${my_coffee.cost()}")
# Saída: Simple coffee + Milk + Sugar: $8

Exemplo de formatação de texto:

class Text:
    def __init__(self, content):
        self.content = content
    
    def render(self):
        return self.content

class BoldDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<b>{self.text.render()}</b>"

class ItalicDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<i>{self.text.render()}</i>"

# Encadeie decoradores
message = Text("Hello World")
message = BoldDecorator(message)
message = ItalicDecorator(message)

print(message.render())
# Saída: <i><b>Hello World</b></i>

Principais benefícios: Permite combinações flexíveis de recursos sem criar muitas subclasses, mantém a referência ao objeto envolvido e adiciona funcionalidade dinamicamente.

Experimente você mesmo

# Importa todas as classes necessárias
from beverage import Espresso, HouseBlend, DarkRoast, Decaf
from condiment_decorator import Milk, Mocha, Soy, Whip

# Manipulador abrangente de casos de teste
test_case = input()

if test_case == "basic_beverage_test":
    # Testa a funcionalidade básica da bebida
    espresso = Espresso()
    print(f"Description: {espresso.get_description()}")
    print(f"Cost: ${espresso.cost():.2f}")

elif test_case == "all_beverages_test":
    # Testa todos os tipos de bebidas
    beverages = [Espresso(), HouseBlend(), DarkRoast(), Decaf()]
    for beverage in beverages:
        print(f"{beverage.get_description()}: ${beverage.cost():.2f}")

elif test_case == "single_condiment_test":
    # Testa a decoração com um único condimento
    espresso = Espresso()
    espresso_with_milk = Milk(espresso)
    print(f"Description: {espresso_with_milk.get_description()}")
    print(f"Cost: ${espresso_with_milk.cost():.2f}")

elif test_case == "multiple_condiments_test":
    # Testa decorações com múltiplos condimentos
    house_blend = HouseBlend()
    decorated_coffee = Mocha(Soy(Whip(house_blend)))
    print(f"Description: {decorated_coffee.get_description()}")
    print(f"Cost: ${decorated_coffee.cost():.2f}")

elif test_case == "all_condiments_test":
    # Testa todos os condimentos em uma única bebida
    dark_roast = DarkRoast()
    fully_loaded = Milk(Mocha(Soy(Whip(dark_roast))))
    print(f"Description: {fully_loaded.get_description()}")
    print(f"Cost: ${fully_loaded.cost():.2f}")

elif test_case == "cost_calculation_test":
    # Testa cálculos de custo para diferentes combinações
    espresso = Espresso()
    
    # Adições individuais
    with_milk = Milk(espresso)
    with_mocha = Mocha(espresso)
    
    print(f"Espresso: ${espresso.cost():.2f}")
    print(f"Espresso + Milk: ${with_milk.cost():.2f}")
    print(f"Espresso + Mocha: ${with_mocha.cost():.2f}")

elif test_case == "decoration_order_test":
    # Testa se a ordem da decoração não afeta o resultado final
    decaf = Decaf()
    
    order1 = Milk(Mocha(decaf))
    order2 = Mocha(Milk(decaf))
    
    print(f"Order 1 - {order1.get_description()}: ${order1.cost():.2f}")
    print(f"Order 2 - {order2.get_description()}: ${order2.cost():.2f}")
    print(f"Same cost: {order1.cost() == order2.cost()}")

elif test_case == "complex_order_test":
    # Testa pedidos de bebidas complexos
    orders = [
        Mocha(Whip(Espresso())),
        Soy(Milk(HouseBlend())),
        Whip(Mocha(Soy(DarkRoast()))),
        Milk(Decaf())
    ]
    
    for i, order in enumerate(orders, 1):
        print(f"Order {i}: {order.get_description()}")
        print(f"Cost: ${order.cost():.2f}")
        print("---")

elif test_case == "double_condiment_test":
    # Testa a adição do mesmo condimento múltiplas vezes
    espresso = Espresso()
    double_mocha = Mocha(Mocha(espresso))
    print(f"Description: {double_mocha.get_description()}")
    print(f"Cost: ${double_mocha.cost():.2f}")

elif test_case == "beverage_comparison_test":
    # Compara custos de diferentes bebidas com os mesmos condimentos
    base_beverages = [Espresso(), HouseBlend(), DarkRoast(), Decaf()]
    
    print("All beverages with Milk + Mocha:")
    for beverage in base_beverages:
        decorated = Milk(Mocha(beverage))
        print(f"{decorated.get_description()}: ${decorated.cost():.2f}")

elif test_case == "condiment_cost_test":
    # Testa os custos individuais dos condimentos
    espresso = Espresso()
    base_cost = espresso.cost()
    
    condiments = [
        ("Milk", Milk(espresso)),
        ("Mocha", Mocha(espresso)),
        ("Soy", Soy(espresso)),
        ("Whip", Whip(espresso))
    ]
    
    for name, decorated in condiments:
        additional_cost = decorated.cost() - base_cost
        print(f"{name} adds: ${additional_cost:.2f}")

elif test_case == "cheapest_most_expensive_test":
    # Encontra as bebidas base mais barata e mais cara
    beverages = [
        ("Espresso", Espresso()),
        ("House Blend", HouseBlend()),
        ("Dark Roast", DarkRoast()),
        ("Decaf", Decaf())
    ]
    
    beverages.sort(key=lambda x: x[1].cost())
    print(f"Cheapest: {beverages[0][0]} - ${beverages[0][1].cost():.2f}")
    print(f"Most Expensive: {beverages[-1][0]} - ${beverages[-1][1].cost():.2f}")

elif test_case == "nested_decoration_test":
    # Testa decorações profundamente aninhadas
    beverage = HouseBlend()
    # Adiciona 5 camadas de decorações
    decorated = Whip(Soy(Mocha(Milk(Whip(beverage)))))
    print(f"Description: {decorated.get_description()}")
    print(f"Cost: ${decorated.cost():.2f}")
    
    # Conta o número de condimentos
    description = decorated.get_description()
    condiment_count = description.count(" + ")
    print(f"Number of condiments: {condiment_count}")

elif test_case == "cost_breakdown_test":
    # Detalhamento de custos
    dark_roast = DarkRoast()
    print(f"Base Dark Roast: ${dark_roast.cost():.2f}")
    
    with_soy = Soy(dark_roast)
    print(f"+ Soy: ${with_soy.cost():.2f}")
    
    with_mocha = Mocha(with_soy)
    print(f"+ Mocha: ${with_mocha.cost():.2f}")
    
    with_whip = Whip(with_mocha)
    print(f"+ Whip: ${with_whip.cost():.2f}")
    
    final_cost = with_whip.cost()
    print(f"Final total: ${final_cost:.2f}")

elif test_case == "description_format_test":
    # Testa a consistência da formatação da descrição
    espresso = Espresso()
    test_combinations = [
        Milk(espresso),
        Mocha(Milk(espresso)),
        Whip(Mocha(Milk(espresso))),
        Soy(Whip(Mocha(Milk(espresso))))
    ]
    
    for combo in test_combinations:
        description = combo.get_description()
        print(f"Description: '{description}'")
        # Verifica se a descrição começa com o nome da bebida base
        starts_correctly = description.startswith("Espresso")
        print(f"Starts with base name: {starts_correctly}")
        print("---")