Clean Architecture & Design Patterns in Practice · Aula

Fábrica Abstrata e Construtor

Explore a Fábrica Abstrata para criar famílias de objetos relacionados e o Construtor para construir objetos complexos passo a passo.

Fábrica Abstrata e Construtor é uma aula grátis de Clean Architecture & Design Patterns in Practice no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Clean Architecture & Design Patterns in Practice, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Clean Architecture & Design Patterns in Practice inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Patterns for Object Creation

Welcome to this lesson on two powerful creational design patterns: Abstract Factory and Builder.

These patterns help us manage the complex process of creating objects, making our code more flexible and maintainable.

You'll learn when and how to use each to build robust applications.

Abstract Factory: The Problem

Imagine you're building an application that needs to support different 'themes' or 'operating systems' (like Windows and macOS) for its UI components.

You need to create a family of related objects (buttons, checkboxes, text fields) that all belong to a specific theme.

How do you ensure you're always creating the correct set of components for a chosen theme without hardcoding them?

Abstract Factory: The Solution

The Abstract Factory pattern provides an interface for creating families of related or interdependent objects without specifying their concrete classes.

It defines an Abstract Factory (an interface) with methods for creating each product type (e.g., createButton(), createCheckbox()).
Concrete Factories implement this interface, each responsible for creating products of a specific family (e.g., WindowsUIFactory, MacUIFactory).
Your client code interacts only with the abstract factory and abstract products, staying independent of concrete implementations.

Abstract Factory Code: UI Kit

Let's see how an Abstract Factory can create different UI components. Here, we define interfaces for Button and Checkbox, and an UIFactory to produce them for different OS styles.

interface Button {
  void paint();
}

interface Checkbox {
  void paint();
}

class WindowsButton implements Button {
  @Override
  public void paint() {
    System.out.println("Rendered Windows Button");
  }
}

class MacButton implements Button {
  @Override
  public void paint() {
    System.out.println("Rendered Mac Button");
  }
}

class WindowsCheckbox implements Checkbox {
  @Override
  public void paint() {
    System.out.println("Rendered Windows Checkbox");
  }
}

class MacCheckbox implements Checkbox {
  @Override
  public void paint() {
    System.out.println("Rendered Mac Checkbox");
  }
}

interface UIFactory {
  Button createButton();
  Checkbox createCheckbox();
}

class WindowsUIFactory implements UIFactory {
  @Override
  public Button createButton() {
    return new WindowsButton();
  }

  @Override
  public Checkbox createCheckbox() {
    return new WindowsCheckbox();
  }
}

class MacUIFactory implements UIFactory {
  @Override
  public Button createButton() {
    return new MacButton();
  }

  @Override
  public Checkbox createCheckbox() {
    return new MacCheckbox();
  }
}

public class Main {
  public static void main(String[] args) {
    UIFactory factory;
    String os = "Mac"; // Or "Windows"

    if (os.equals("Windows")) {
      factory = new WindowsUIFactory();
    } else {
      factory = new MacUIFactory();
    }

    Button button = factory.createButton();
    Checkbox checkbox = factory.createCheckbox();

    button.paint();
    checkbox.paint();
  }
}

Builder Pattern: Complex Objects

Now, let's switch gears to the Builder pattern. Imagine you need to create a complex object, like a custom computer or a detailed report.

This object might have many optional parts, and its construction can involve a specific sequence of steps.

If you try to use a constructor with many parameters, it quickly becomes unreadable and hard to manage.

Builder Pattern: The Process

The Builder pattern separates the construction of a complex object from its representation.

A separate Builder object is responsible for constructing the final Product step-by-step.
It provides a fluent API (method chaining) to set various properties or parts of the object.
Finally, a build() method returns the fully constructed object.
This makes object creation code much cleaner and more readable, especially for objects with many optional parameters.

Builder Code: Custom Pizza!

Let's use the Builder pattern to create a custom Pizza. We can specify the crust, sauce, cheese, and toppings step-by-step, making the creation process clear.

class Pizza {
  private String crust;
  private String sauce;
  private String cheese;
  private String toppings;

  public Pizza(String crust, String sauce, String cheese, String toppings) {
    this.crust = crust;
    this.sauce = sauce;
    this.cheese = cheese;
    this.toppings = toppings;
  }

  @Override
  public String toString() {
    return "Pizza with: " + crust + " crust, " + sauce + " sauce, " + cheese + " cheese, " + toppings + ".";
  }
}

class PizzaBuilder {
  private String crust = "thin";
  private String sauce = "tomato";
  private String cheese = "mozzarella";
  private String toppings = "none";

  public PizzaBuilder withCrust(String crust) {
    this.crust = crust;
    return this;
  }

  public PizzaBuilder withSauce(String sauce) {
    this.sauce = sauce;
    return this;
  }

  public PizzaBuilder withCheese(String cheese) {
    this.cheese = cheese;
    return this;
  }

  public PizzaBuilder withToppings(String toppings) {
    this.toppings = toppings;
    return this;
  }

  public Pizza build() {
    return new Pizza(crust, sauce, cheese, toppings);
  }
}

public class Main {
  public static void main(String[] args) {
    Pizza margherita = new PizzaBuilder()
      .withCrust("classic")
      .withSauce("tomato")
      .withCheese("mozzarella")
      .build();
    System.out.println(margherita);

    Pizza veggieDelight = new PizzaBuilder()
      .withCrust("whole wheat")
      .withSauce("pesto")
      .withCheese("feta")
      .withToppings("onions, peppers, olives")
      .build();
    System.out.println(veggieDelight);
  }
}

Patterns Compared

While both patterns deal with object creation, they solve different problems:

Abstract Factory: Focuses on creating families of related objects. It provides a way to encapsulate a group of individual factories that have a common theme without exposing the concrete classes.
Builder: Focuses on creating a single complex object step-by-step. It's ideal when an object has many parameters, some optional, and its construction involves a multi-stage process.

Abstract Factory returns a factory, Builder returns the product itself.

Practical Applications

You'll find these patterns in many real-world scenarios:

Abstract Factory: Database connection factories (e.g., creating specific connection objects for MySQL, PostgreSQL, Oracle), cross-platform UI toolkits, or creating different configurations of a system.
Builder: Constructing complex SQL queries, generating reports with many customizable sections, configuring HTTP requests, or creating complex data transfer objects (DTOs).

They bring clarity and flexibility to object instantiation.

Quick Check

Consider the problems below. Which of them are typically best solved using the Abstract Factory pattern?

Abstract Factory & Builder Recap

Great job! In this lesson, you explored two powerful creational patterns:

Abstract Factory: Best for creating families of related objects, ensuring consistency across different implementations.
Builder: Perfect for constructing complex objects step-by-step, especially when they have many optional parts, making the creation process clear and manageable.

These patterns are crucial tools for designing flexible and maintainable software systems.

Perguntas Frequentes

A aula “Fábrica Abstrata e Construtor” é grátis?

Sim — o texto completo de “Fábrica Abstrata e Construtor” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Clean Architecture & Design Patterns in Practice, atualize para CoddyKit PRO. O curso de Clean Architecture & Design Patterns in Practice inclui 4 aulas no total.

O que vou aprender em “Fábrica Abstrata e Construtor”?

Explore a Fábrica Abstrata para criar famílias de objetos relacionados e o Construtor para construir objetos complexos passo a passo. Você pratica Clean Architecture & Design Patterns in Practice com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Clean Architecture & Design Patterns in Practice?

Nenhuma experiência prévia é necessária. Clean Architecture & Design Patterns in Practice no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Fábrica Abstrata e Construtor”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Clean Architecture & Design Patterns in Practice?

Sim. Cada aula de Clean Architecture & Design Patterns in Practice inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Singleton e Método de Fábrica
Fábrica Abstrata e Construtor
Protótipo e Pool de Objetos
Injeção de dependências como técnica de criação

← Voltar para Clean Architecture & Design Patterns in Practice