Padrão Builder

Parte da seção Programação Orientada a Objetos do Journey de Java da Coddy. Lição 67 de 87.

O Builder Pattern é um padrão de projeto criacional que resolve um problema comum: construir objetos complexos com muitos parâmetros opcionais. Em vez de criar vários construtores ou passar null para parâmetros não utilizados, o Builder permite construir objetos passo a passo.

Considere criar um objeto User com campos obrigatórios (nome, e-mail) e opcionais (idade, telefone, endereço). Sem um Builder, você precisaria de construtores telescópicos ou de um construtor confuso com muitos parâmetros. O padrão Builder oferece uma abordagem mais organizada:

public class User {
    private final String name;    // obrigatório
    private final String email;   // obrigatório
    private final int age;        // opcional
    private final String phone;   // opcional
    
    private User(UserBuilder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
        this.phone = builder.phone;
    }
    
    public static class UserBuilder {
        private final String name;
        private final String email;
        private int age;
        private String phone;
        
        public UserBuilder(String name, String email) {
            this.name = name;
            this.email = email;
        }
        
        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }
        
        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }
        
        public User build() {
            return new User(this);
        }
    }
}

Os métodos do Builder retornam this, permitindo o : uma maneira fluente e legível de construir objetos:

User user = new User.UserBuilder("Alice", "alice@email.com")
    .age(25)
    .phone("555-1234")
    .build();

Observe como o construtor de User é privado: os objetos só podem ser criados por meio do Builder. Esse padrão se destaca quando os objetos têm muitos campos opcionais, tornando seu código mais legível e menos sujeito a erros do que listas longas de parâmetros.

Desafio
Fácil

Vamos criar um sistema de pedidos de pizza usando o Padrão Builder! Em vez de lidar com um construtor que recebe dezenas de parâmetros para todas as possíveis coberturas e opções, você criará um builder fluente que torna a personalização da pizza simples e legível.

Você organizará seu código em dois arquivos:

Pizza.java: Crie uma classe Pizza que use o Padrão Builder para a construção. Sua pizza deve ter os seguintes campos:
size (String) - obrigatório, representa o tamanho da pizza

cheese (boolean) - opcional, o padrão é false

pepperoni (boolean) - opcional, o padrão é false

mushrooms (boolean) - opcional, o padrão é false

O construtor de Pizza deve ser privado e aceitar apenas um PizzaBuilder como parâmetro, copiando todos os valores do builder para os campos da pizza.

Inclua um método getDescription() que retorne uma string neste formato: [size] Pizza with: [toppings], em que toppings é uma lista separada por vírgulas das coberturas que são true (Cheese, Pepperoni, Mushrooms). Se nenhuma cobertura for selecionada, a parte de toppings deve simplesmente dizer no toppings.

Crie uma classe interna estática PizzaBuilder com:

Um construtor que receba o parâmetro obrigatório size

Métodos cheese(), pepperoni() e mushrooms() que definam cada booleano correspondente como true e retornem this para encadeamento

Um método build() que retorne uma nova Pizza

Main.java: Demonstre seu builder de pizza em ação! Você receberá quatro entradas: o tamanho da pizza (String) e três valores sim/não (Strings) indicando se deve adicionar queijo, pepperoni e cogumelos, respectivamente.
Crie um PizzaBuilder com o tamanho fornecido. Em seguida, com base em cada entrada sim/não, encadeie os métodos de cobertura apropriados. Se a entrada for "yes", chame o método da cobertura correspondente; se for "no", ignore-o. Por fim, chame build() para criar sua pizza.

Imprima o resultado da chamada de getDescription() na pizza concluída.

Você receberá quatro entradas na seguinte ordem: tamanho (String), adicionar queijo (String: "yes" ou "no"), adicionar pepperoni (String: "yes" ou "no"), adicionar cogumelos (String: "yes" ou "no").

Por exemplo, com as entradas Large, yes, no, yes, sua saída seria: Large Pizza with: Cheese, Mushrooms

Observe como o Padrão Builder permite construir pizzas com qualquer combinação de coberturas sem precisar de construtores separados para cada possibilidade!

Experimente você mesmo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Ler entradas
        String size = scanner.nextLine();
        String addCheese = scanner.nextLine();
        String addPepperoni = scanner.nextLine();
        String addMushrooms = scanner.nextLine();
        
        // TODO: Crie um PizzaBuilder com o tamanho fornecido
        // TODO: Encadeie os métodos de cobertura com base nas entradas sim/não
        // TODO: Construa a pizza e imprima sua descrição
        
    }
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Programação Orientada a Objetos

1Fundamentos de POO

Arquivos Externos Introdução à POO Classes vs Objetos A Palavra-chave this Métodos Campos (Atributos)Método Construtor Sobrecarga de Construtor Recapitulação - Calculadora Simples

4Herança

Herança Básica (extends)A Palavra-chave super Sobrescrita de Método (@Override)Encadeamento de Construtores A Classe Object Herança Simples e Multinível Por que não há Herança Múltipla de Classes Recapitulação - Hierarquia de Funcionários

7Métodos Especiais e a Classe Object

Método toString()equals() e hashCode()Método clone()compareTo() e Comparable Interface Comparator Recapitulação - Ordenação Personalizada

10Tratamento de Exceções em POO

Hierarquia de Classes de Exceção Exceções Personalizadas Erros Checked vs Unchecked Padrão Try With Resources Recapitulação - Usuário Validado

13Projeto: Gerenciamento de Biblioteca

Visão Geral do Projeto e Modelagem UML Classes Livro e Usuário Sistema de Empréstimos Funcionalidade de Busca Interface do Administrador Integração de Tratamento de Exceções Testes e Integração

2Modificadores de Acesso e Encapsulamento

Visão Geral dos Níveis de Acesso Métodos Getter e Setter Ocultação de Informações A Palavra-chave final Recapitulação - Gerenciador de Conta Bancária

5Polimorfismo

Fundamentos de Sobrecarga de Métodos Sobrescrita de Métodos (Tempo de Execução)Upcasting e Downcasting O Operador instanceof Classes e Métodos Abstratos Recapitulação - Calculadora de Formas

8Conceitos Avançados de OOP

Composição vs Herança Agregação vs Composição Classes Internas, Aninhadas e Anônimas Enums e Métodos de Enum Records (Java 16+)Classes Seladas (Java 17+)

11Padrões de Projeto Parte 1

Introdução aos Padrões de Projeto Padrão Singleton Padrão FactoryPadrão BuilderPadrão Observer Padrão Strategy

14Desafios Finais

Plataforma de E-Learning Sistema Bancário Desenvolvimento de Personagens de Jogos Serviço de Aluguel de Veículos

3Propriedades de Classe e Membros Estáticos

Variáveis de Instância vs Estáticas Métodos Estáticos Blocos Estáticos Constantes (static final)Recapitulação - Contador e Utilitário

6Interfaces e Classes Abstratas

Introdução às Interfaces Implementando Interfaces Implementação de Múltiplas Interfaces Default e Static em Interfaces Classes Abstratas vs Interfaces Interfaces Funcionais Recapitulação - Sistema de Pagamento

9Generics

Introdução a Generics Classes Genéricas Métodos Genéricos Parâmetros de Tipos Delimitados Wildcards (?, extends, super)Recapitulação - Container Genérico

12Padrões de Projeto Parte 2

Padrão Command Padrão Adapter Padrão Decorator Padrão Template Method Padrão State Padrão Composite Padrão Iterator

Pratique por conta própria: Compilador de Java online