Design Patterns – Builder

Se você já se viu na situação de criar objetos complexos em seus projetos de programação, como se estivesse montando um quebra-cabeça gigante, você não está sozinho! Essa tarefa pode ser desafiadora e, muitas vezes, a forma convencional de construir esses objetos pode levar a um verdadeiro caos no código. Mas não se preocupe, o Builder está aqui para salvar o dia e evitar que você surte na frente do computador!

O Builder é um design pattern (padrão de criação) que separa a construção de um objeto complexo na sua representação, de modo que o mesmo processo de construção possa criar diferentes representações.

Nesse caso a ideia é de que os resultados podem ser tantos, que é difícil preve-los ou simular uma interface que comportaria e atenderia a todos.

Tá, mas como isso funciona na prática?

Imagine que você está desenvolvendo um sistema para uma loja online que vende produtos personalizados, como camisetas e bonés. Cada produto pode ter várias opções de personalização, como cor, tamanho, estampa e tipo de tecido. Com o padrão Builder, você pode separar a lógica de construção desses objetos complexos da sua representação final. Isso significa que você pode ter diferentes tipos de builders que constroem o mesmo produto, mas com diferentes configurações.

Vamos dar uma olhada em como aplicar o padrão Builder nesse contexto. Primeiro, você pode definir uma interface ou classe abstrata chamada “Builder” que contenha métodos para construir diferentes partes do produto. Por exemplo:

interface ProdutoBuilder {
    void construirParteA();
    void construirParteB();
    void construirParteC();
    // ... e assim por diante
}

Em seguida, você pode criar uma classe concreta que implemente a interface do Builder para construir um tipo específico de produto, como uma camiseta:

class CamisetaBuilder implements ProdutoBuilder {
    private Camiseta camiseta;

    public CamisetaBuilder() {
        this.camiseta = new Camiseta();
    }

    @Override
    public void construirParteA() {
        // Lógica para construir a parte A da camiseta
    }

    @Override
    public void construirParteB() {
        // Lógica para construir a parte B da camiseta
    }

    @Override
    public void construirParteC() {
        // Lógica para construir a parte C da camiseta
    }

    public Camiseta obterCamiseta() {
        return this.camiseta;
    }
}

Dessa forma, você pode criar diferentes builders para construir camisetas com estilos diferentes, por exemplo:

class CamisetaEstampadaBuilder extends CamisetaBuilder {
    @Override
    public void construirParteA() {
        // Lógica para construir a parte A da camiseta estampada
    }

    @Override
    public void construirParteB() {
        // Lógica para construir a parte B da camiseta estampada
    }
}

Agora, quando você precisa construir um objeto complexo, como uma camiseta personalizada, pode usar o padrão Builder para simplificar o processo:

public class LojaOnline {
    public static void main(String[] args) {
        // Construindo uma camiseta estampada
        CamisetaBuilder builder = new CamisetaEstampadaBuilder();
        builder.construirParteA();
        builder.construirParteB();
        Camiseta camisetaEstampada = builder.obterCamiseta();

        // Construindo outra camiseta com outro builder
        CamisetaBuilder outroBuilder = new OutroTipoDeBuilder();
        outroBuilder.construirParteA();
        outroBuilder.construirParteC();
        Camiseta outroTipoDeCamiseta = outroBuilder.obterCamiseta();

        // Agora você tem duas camisetas construídas de maneira flexível e modular!
    }
}

O padrão Builder oferece uma maneira elegante de criar objetos complexos, permitindo que você tenha diferentes builders para diferentes configurações e, ao mesmo tempo, isolando a lógica de construção do objeto em classes separadas. Isso torna o código mais legível, fácil de dar manutenção e facilita a adição de novos tipos de produtos no futuro, sem afetar o código existente.

Então, da próxima vez que você se deparar com a necessidade de construir objetos complexos em seus projetos, você pode considerar a utilização do padrão Builder. Ele pode ser a solução ideal para tornar o seu código mais organizado, modular e preparado para enfrentar novos desafios de forma mais eficiente.

E já que uma imagem vale mais do que mil palavras, deixo aqui, mais uma vez, uma explicação à la Homer Simpson:

// Comente!

comentários