Aula 18: Introdução a Design Patterns

Por que Usar Padrões de Projeto?

• Reutilização: Evitam reinventar a roda, oferecendo soluções comprovadas.
• Comunicação: Fornecem um vocabulário comum entre desenvolvedores.
• Manutenibilidade: Levam a sistemas mais flexíveis e fáceis de manter.
• Modularidade: Ajudam a criar sistemas mais desacoplados.

Propósito:

Ele remove a responsabilidade de instanciar objetos diretamente do código cliente, delegando-a a um método de fábrica. Isso torna o sistema mais flexível, pois o código cliente não precisa saber a classe exata do objeto que está sendo criado.

# Exemplo de Factory Method em Python

# Classes de Produtos
class Carro:
    def __init__(self, modelo):
        self.modelo = modelo
    def __str__(self):
        return f"Carro: {self.modelo}"

class Moto:
    def __init__(self, tipo):
        self.tipo = tipo
    def __str__(self):
        return f"Moto: {self.tipo}"

# Classe Fábrica Abstrata (ou Interface)
class VeiculoFactory:
    def criar_veiculo(self, tipo_veiculo):
        raise NotImplementedError("Este método deve ser implementado pelas subclasses")

# Fábricas Concretas
class CarroFactory(VeiculoFactory):
    def criar_veiculo(self, modelo):
        return Carro(modelo)

class MotoFactory(VeiculoFactory):
    def criar_veiculo(self, tipo):
        return Moto(tipo)

# Uso:
# carro_fabrica = CarroFactory()
# meu_carro = carro_fabrica.criar_veiculo("Sedan")
# print(meu_carro) # Saída: Carro: Sedan

# moto_fabrica = MotoFactory()
# minha_moto = moto_fabrica.criar_veiculo("Esportiva")
# print(minha_moto) # Saída: Moto: Esportiva

Propósito:

É útil quando você precisa de apenas um objeto para coordenar ações em todo o sistema, como um gerenciador de logs, uma configuração de aplicativo ou um pool de conexões de banco de dados.

# Exemplo de Singleton em Python

class Configuracao:
    _instance = None # Armazena a única instância

    def __new__(cls):
        if cls._instance is None:
            # Cria a instância apenas se ela ainda não existir
            cls._instance = super(Configuracao, cls).__new__(cls)
            cls._instance.config = {} # Inicializa a configuração
            print("Configuração inicializada (primeira vez).")
        return cls._instance

    def set_config(self, chave, valor):
        self.config[chave] = valor
        print(f"Configuração '{chave}' definida como '{valor}'.")

    def get_config(self, chave):
        return self.config.get(chave, "Não encontrado")

# Uso:
# conf1 = Configuracao() # Primeira vez, inicializa
# conf1.set_config("tema", "dark")

# conf2 = Configuracao() # Retorna a mesma instância existente
# conf2.set_config("idioma", "pt-br")

# print(f"Configuração tema (via conf1): {conf1.get_config('tema')}")
# print(f"Configuração idioma (via conf2): {conf2.get_config('idioma')}")

# print(f"conf1 é a mesma instância que conf2? {conf1 is conf2}") # Saída: True

Código Python das Classes Simuladas

# Classes para Factory Method
class Animal:
    def __init__(self, especie):
        self.especie = especie
    def fazer_som(self):
        return "Som genérico"
    def __str__(self):
        return f"Animal: {self.especie}"

class Cachorro(Animal):
    def __init__(self, nome):
        super().__init__("Cachorro")
        self.nome = nome
    def fazer_som(self):
        return "Au Au!"
    def __str__(self):
        return f"Cachorro: {self.nome}"

class Gato(Animal):
    def __init__(self, nome):
        super().__init__("Gato")
        self.nome = nome
    def fazer_som(self):
        return "Miau!"
    def __str__(self):
        return f"Gato: {self.nome}"

class AnimalFactory:
    @classmethod
    def criar_animal(cls, tipo, nome=None):
        if tipo == "cachorro":
            return Cachorro(nome)
        elif tipo == "gato":
            return Gato(nome)
        else:
            return Animal("Desconhecido")

# Classe para Singleton
class Logger:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Logger, cls).__new__(cls)
            cls._instance.logs = []
            print("Logger inicializado (primeira vez).")
        return cls._instance

    def log(self, mensagem):
        self.logs.append(mensagem)
        print(f"LOG: {mensagem}")

    def mostrar_logs(self):
        return "\n".join(self.logs)