Abstract Factory é um padrão de design criacional que permite criar objetos relacionados sem especificar suas classes concretas.

Declaração do problema

Imagine que você está desenvolvendo um kit de ferramentas GUI que deve suportar vários padrões de aparência (por exemplo, Windows, macOS, Linux). Cada padrão de aparência requer um conjunto diferente de componentes de UI, como botões, caixas de seleção e barras de rolagem.

Sem o padrão Abstract Factory, você teria que escrever muito código condicional para lidar com a criação desses componentes com base no padrão de aparência atual. Essa abordagem não é escalável e torna a base de código difícil de manter e estender.

Ao usar o padrão Abstract Factory, você pode criar uma interface para criar famílias de objetos relacionados (por exemplo, botões, caixas de seleção, barras de rolagem) e implementar essa interface para cada padrão de aparência. Dessa forma, o código do cliente pode funcionar com qualquer padrão de aparência sem conhecer os detalhes de como os componentes são criados.

Exemplo do mundo real

Considere uma fábrica de móveis que produz cadeiras e mesas em diferentes estilos, como clássico e moderno.

Cada estilo requer um conjunto diferente de componentes (por exemplo, pernas, encosto, apoios de braços) e materiais (por exemplo, madeira, metal, plástico).

Implementação

• Execute o exemplo executando go run abstract-factory/main.go.

package main

import "fmt"

// Abstract Factory
type FurnitureFactory interface {
    MakeChair() Chair
    MakeTable() Table
}

func NewFurnitureFactory(style string) (FurnitureFactory, error) {
    if style == "classic" {
        return &Classic{}, nil
    }

    if style == "modern" {
        return &Modern{}, nil
    }

    return nil, fmt.Errorf("Style %s is not supported", style)
}

type Chair struct {
    Name     string
    Material string
}

type Table struct {
    Name     string
    Material string
}

// Concrete Classic Factory
type Classic struct{}

func (a *Classic) MakeChair() Chair {
    return Chair{
        Name:     "Classic Chair",
        Material: "Wood",
    }
}

func (a *Classic) MakeTable() Table {
    return Table{
        Name:     "Classic Table",
        Material: "Wood",
    }
}

// Concrete Modern Factory
type Modern struct{}

func (n *Modern) MakeChair() Chair {
    return Chair{
        Name:     "Modern Chair",
        Material: "Plastic",
    }
}

func (n *Modern) MakeTable() Table {
    return Table{
        Name:     "Modern Table",
        Material: "Plastic",
    }
}

func main() {
    factory, _ := NewFurnitureFactory("classic")

    chair := factory.MakeChair()
    table := factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)

    factory, _ = NewFurnitureFactory("modern")

    chair = factory.MakeChair()
    table = factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)
}

Explicação

Este código demonstra o padrão Abstract Factory criando móveis (cadeiras e mesas) em diferentes estilos (clássico e moderno). Define uma interface para criação de famílias de objetos relacionados e implementações concretas para cada estilo, permitindo fácil escalabilidade e manutenção.