Introdução
Imagine que temos um sistema em que há no código diversos new ClasseConcreta(). Essa prática, que é comum em aplicações criar dois tipos de problemas, que piora a medida que o sistema evolui.
O primeiro problema é o acoplamento direto entre classes concretas. Se um sistema escreve new BotaoWindows() diretamente, ele não funciona em outro contexto (Mac, Linux, tema escuro) sem ter que reescrever essas linhas. Viola o Princípio da Inversão de Dependência, que diz que módulos de alto nível não devem depender de detalhes de implementaçõa.
O segundo problema é mais sutil e é o que de fato motiva o Abstract Factory: nada garante que os objetos criados em pontos diferentes do código são compatíveis entre si. Se um botão "estilo Windows" é criado em um lugar e uma scrollbar "estilo Mac" é criada em outro, nada impede que os dois acabem compondo a mesma tela, um bug visual silencioso, que só aparece em produção.
O exemplo canônico do próprio catálogo GoF (1994) é exatamente esse: bibliotecas de interface gráfica que precisam renderizar os mesmos componentes como botão, checkbox e scrollbar com aparências diferentes por sistema operacional. É o caso mais didático porque a família de objetos é visualmente óbvia: ou tudo é Windows, ou tudo é Mac, nunca uma mistura.
Motivação prática
Uma dúvida natural nesse ponto: por que não resolver isso com um Factory Method, uma fábrica simples que cria o botão certo? A resposta é que Factory Method resolve a criação de um objeto por vez, mas não oferece nenhum mecanismo para garantir que vários objetos criados juntos pertencem à mesma variante.
Imagine três Factory Methods isolados: CriarBotao(), CriarCheckbox(), CriarScrollbar(), cada um decidindo individualmente se retorna a versão Windows ou Mac. Nada no código impede que, por um erro de configuração ou uma falha de propagação de contexto, um deles decida errado — o botão vem Windows e a scrollbar vem Mac, porque as três decisões são independentes entre si.
O Abstract Factory resolve isso amarrando as três decisões em um único objeto: a fábrica concreta. Ao obter a fábrica uma única vez, o código cliente tem a garantia estrutural de que qualquer componente que ele pedir dali em diante pertence à mesma família, porque todos vêm do mesmo objeto, que só sabe criar uma variante.
Definição formal e papéis
A definição do GoF: "Fornecer uma interface para criar famílias de objetos relacionados ou dependentes, sem especificar suas classes concretas."
O padrão define cinco papéis, e vale fixar o vocabulário exato — ele torna a comunicação em revisão de código muito mais precisa do que descrever o mecanismo por extenso:
| Papel GoF | Responsabilidade | No exemplo da UI |
|---|---|---|
| AbstractFactory | Interface que declara um método de criação por produto da família | IUiComponentFactory |
| ConcreteFactory | Implementa a interface, garantindo que todos os produtos retornados sejam da mesma variante |
WindowsUiFactory, MacUiFactory
|
| AbstractProduct | Interface de um dos produtos da família |
IBotao, ICheckbox, IScrollbar
|
| ConcreteProduct | Implementação concreta de um produto, pertencente a uma variante específica |
BotaoWindows, CheckboxMac
|
| Client | Código que usa apenas as interfaces abstratas, nunca referenciando um tipo concreto diretamente | O código de renderização da tela |
O ponto que mais gera confusão: o Client conhece a AbstractFactory e as interfaces de produto, mas nunca, em nenhuma circunstância, referencia uma ConcreteFactory ou um ConcreteProduct diretamente no código — essa referência existe só no ponto de composição, normalmente a configuração de injeção de dependência.
Estrutura
!image.png
O Client depende só da AbstractFactory; cada ConcreteFactory amarra a criação de três produtos (IBotao, ICheckbox, IScrollbar) em uma única família consistente, impedindo que um produto de uma variante seja misturado com o de outra.
Implementação em código
// Interfaces de produto (AbstractProduct)
public interface IBotao
{
void Renderizar();
}
public interface ICheckbox
{
void Renderizar();
}
public interface IScrollbar
{
void Renderizar();
}
// Produtos concretos — variante Windows
public class BotaoWindows : IBotao
{
public void Renderizar() => Console.WriteLine("Botão estilo Windows");
}
public class CheckboxWindows : ICheckbox
{
public void Renderizar() => Console.WriteLine("Checkbox estilo Windows");
}
public class ScrollbarWindows : IScrollbar
{
public void Renderizar() => Console.WriteLine("Scrollbar estilo Windows");
}
// Produtos concretos — variante Mac
public class BotaoMac : IBotao
{
public void Renderizar() => Console.WriteLine("Botão estilo Mac");
}
public class CheckboxMac : ICheckbox
{
public void Renderizar() => Console.WriteLine("Checkbox estilo Mac");
}
public class ScrollbarMac : IScrollbar
{
public void Renderizar() => Console.WriteLine("Scrollbar estilo Mac");
}
// AbstractFactory
public interface IUiComponentFactory
{
IBotao CriarBotao();
ICheckbox CriarCheckbox();
IScrollbar CriarScrollbar();
}
// ConcreteFactory — Windows
public class WindowsUiFactory : IUiComponentFactory
{
public IBotao CriarBotao() => new BotaoWindows();
public ICheckbox CriarCheckbox() => new CheckboxWindows();
public IScrollbar CriarScrollbar() => new ScrollbarWindows();
}
// ConcreteFactory — Mac
public class MacUiFactory : IUiComponentFactory
{
public IBotao CriarBotao() => new BotaoMac();
public ICheckbox CriarCheckbox() => new CheckboxMac();
public IScrollbar CriarScrollbar() => new ScrollbarMac();
}
// Client — nunca referencia um tipo concreto
public class Tela
{
private readonly IUiComponentFactory _factory;
public Tela(IUiComponentFactory factory) => _factory = factory;
public void Renderizar()
{
_factory.CriarBotao().Renderizar();
_factory.CriarCheckbox().Renderizar();
_factory.CriarScrollbar().Renderizar();
}
}
Repare que Tela recebe a fábrica pronta — normalmente via injeção de dependência — e nunca decide sozinha qual variante usar. Trocar de Windows para Mac é uma troca de uma única linha de configuração, não uma mudança espalhada pelo código.
Abstract Factory vs. Factory Method
Esse é o ponto de confusão mais comum entre os dois padrões criacionais, e vale a pena fixar a diferença de uma vez.
Na prática, é comum uma Abstract Factory usar Factory Methods internamente, cada CriarBotao(), CriarCheckbox() dentro de uma ConcreteFactory é, isoladamente, um Factory Method. A diferença está em um nível acima: o Abstract Factory agrupa vários desses métodos em uma interface única, para que a escolha da variante seja feita uma vez só, não a cada chamada.
| Factory Method | Abstract Factory | |
|---|---|---|
| O que cria | Um único produto | Uma família inteira de produtos relacionados |
| Mecanismo | Herança/polimorfismo — uma subclasse sobrescreve o método de criação | Composição — um objeto (a fábrica) agrupa vários métodos de criação |
| O que garante | Que o tipo certo de produto seja criado | Que vários produtos criados juntos sejam compatíveis entre si |
| Quando usar sozinho | Uma única decisão de criação varia | Mais de um produto varia junto, pela mesma razão (ex.: mesmo tema, mesma plataforma) |
Quando usar e quando não usar
O critério de decisão central é: qual eixo de variação cresce mais rápido na prática?
- Se novas famílias inteiras (novas plataformas, novos temas, novos fornecedores) aparecem com frequência, e o conjunto de produtos dentro de cada família é relativamente estável, o padrão compensa, adicionar uma família nova é uma classe nova, sem tocar nas existentes.
- Se, ao contrário, novos tipos de produto dentro da família aparecem com frequência (um componente novo que toda variante precisa suportar), o padrão cobra um preço alto porque cada produto novo exige alterar todas as
ConcreteFactoryexistentes, mesmo as que ainda não suportam aquele componente.
Na dúvida, comece sem o padrão. Introduza-o no momento em que adicionar uma segunda ou terceira variante exigiria trocar manualmente três ou mais classes em vários pontos do código — esse é o sinal concreto de que a indireção está pagando seu próprio custo.
Conclusão
Abstract Factory não é sobre criar objetos, é sobre garantir que um conjunto de objetos criados juntos permaneça consistente, movendo essa garantia de uma convenção implícita ("lembre de criar tudo da mesma variante") para uma estrutura que torna o erro mais difícil de acontecer. O preço dessa garantia é uma interface que cresce junto com cada novo tipo de produto da família e por isso a decisão de adotar o padrão é, na prática, uma aposta sobre qual eixo do seu sistema vai crescer mais: famílias novas, ou produtos novos dentro das famílias existentes.
Top comments (0)