Fale sobre o padrão de design 'Construtor'.

O padrão de design "Builder" (Construtor) é um padrão de criação que permite criar objetos complexos passo a passo. Ele separa o processo de construção de um objeto complexo de sua representação, de modo que o mesmo processo de construção pode criar diferentes representações.

Componentes principais:

• Construtor (Builder): Interface ou classe abstrata que define os métodos para criar partes de um objeto complexo.
• Construtor Concreto (Concrete Builder): Implementa a interface do construtor e fornece uma implementação concreta para construir as partes do objeto. Armazena o resultado intermediário e fornece um método para obter o objeto final.
• Diretor (Director): Componente opcional. Define a ordem em que os métodos do construtor são chamados para criar o objeto. Não conhece os construtores concretos.
• Produto (Product): Objeto complexo criado pelo construtor.

Aplicações:

• Quando o processo de criação do objeto é complexo e inclui múltiplos passos opcionais.
• Quando é necessário criar diferentes representações de um mesmo objeto usando o mesmo processo de construção.
• Quando o construtor do objeto possui muitos parâmetros.

Exemplo em Go:

// Produto - objeto complexo
type Product struct {
	PartA string
	PartB string
	PartC string
}

// Builder - interface do construtor
type Builder interface {
	BuildPartA()
	BuildPartB()
	BuildPartC()
	GetProduct() *Product
}

// ConstrutorConcreto - construtor concreto
type ConcreteBuilder struct {
	product *Product
}

func NewConcreteBuilder() *ConcreteBuilder {
	return &ConcreteBuilder{product: &Product{}}
}

func (cb *ConcreteBuilder) BuildPartA() {
	cb.product.PartA = "Parte A construída"
}

func (cb *ConcreteBuilder) BuildPartB() {
	cb.product.PartB = "Parte B construída"
}

func (cb *ConcreteBuilder) BuildPartC() {
	cb.product.PartC = "Parte C construída"
}

func (cb *ConcreteBuilder) GetProduct() *Product {
	return cb.product
}

// Diretor - diretor (opcional)
type Director struct {
	builder Builder
}

func NewDirector(builder Builder) *Director {
	return &Director{builder: builder}
}

func (d *Director) Construct() {
	d.builder.BuildPartA()
	d.builder.BuildPartB()
	d.builder.BuildPartC()
}

// Uso
// concreteBuilder := NewConcreteBuilder()
// director := NewDirector(concreteBuilder)
// director.Construct()
// product := concreteBuilder.GetProduct()
// fmt.Printf("Produto criado: %+v\n", product)

Vantagens:

• Isola o código de construção do objeto do código cliente.
• Permite alterar a representação interna do produto sem modificar o código cliente.
• Permite construir o objeto passo a passo.
• Simplifica a criação de objetos com muitos parâmetros.

Desvantagens:

• Aumenta a quantidade de código (classes/interfaces) para criar o objeto.
• Pode ser redundante para objetos simples.