Clean Architecture & Design Patterns in Practice · Aula

Padrões Composto e Ponte

Trabalhe com o Composto para criar estruturas semelhantes a árvores e com a Ponte para desacoplar a abstração da implementação.

Padrões Composto e Ponte é uma aula grátis de Clean Architecture & Design Patterns in Practice no CoddyKit. Esta é a aula 3 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.

Composite: Grouping Objects

Imagine you're building a system where individual objects and groups of objects need to be treated uniformly. This is where the Composite pattern shines!

It lets you compose objects into tree structures to represent part-whole hierarchies. This way, clients can treat individual objects and compositions of objects uniformly.

Components, Leaves, & Composites

The Composite pattern involves three main roles:

Component: The common interface or abstract class for both individual objects (leaves) and composite objects.
Leaf: Represents individual objects that don't have children.
Composite: Represents objects that can have children (other Components). It manages child components and delegates operations to them.

Composite in Action: File System

Let's model a file system. A File is a leaf, and a Folder is a composite. Both are FileSystemComponents.

Try running this example:

interface FileSystemComponent {
  void display(int indent);
}

class File implements FileSystemComponent {
  private String name;
  public File(String name) { this.name = name; }
  @Override
  public void display(int indent) {
    System.out.println("  ".repeat(indent) + "File: " + name);
  }
}

class Folder implements FileSystemComponent {
  private String name;
  private java.util.List<FileSystemComponent> children = new java.util.ArrayList<>();
  public Folder(String name) { this.name = name; }
  public void add(FileSystemComponent component) {
    children.add(component);
  }
  @Override
  public void display(int indent) {
    System.out.println("  ".repeat(indent) + "Folder: " + name);
    for (FileSystemComponent child : children) {
      child.display(indent + 1);
    }
  }
}

public class Main {
  public static void main(String[] args) {
    File file1 = new File("report.pdf");
    File file2 = new File("image.jpg");
    Folder documents = new Folder("Documents");
    documents.add(file1);
    documents.add(file2);

    Folder root = new Folder("Root");
    root.add(documents);
    root.add(new File("README.txt"));

    root.display(0);
  }
}

Building & Traversing Trees

In the example, FileSystemComponent is our common interface. Both File (leaf) and Folder (composite) implement it.

Folder can hold other FileSystemComponents, allowing us to build a hierarchical structure. The display method works uniformly whether it's a file or a folder!

Why Use Composite?

The Composite pattern offers several advantages:

Client Simplicity: Clients don't need to distinguish between individual objects and groups of objects when performing operations.
Flexibility: It's easy to add new types of components (files or folders) without changing existing client code.
Tree Structures: Naturally represents hierarchies where objects are composed into larger objects.

Bridge: Decoupling Abstraction

The Bridge pattern helps you "bridge" the gap between an abstraction and its implementation. It decouples them so they can vary independently.

This is useful when you have multiple ways to implement a feature, and you want to avoid a "class explosion" or tight coupling.

Abstraction, Implementor, & More

The Bridge pattern involves these key parts:

Abstraction: Defines the client-facing interface. It holds a reference to an Implementor object.
Refined Abstraction: Extends Abstraction, providing variations.
Implementor: Defines the interface for implementation classes. It doesn't have to match the Abstraction's interface exactly.
Concrete Implementor: Implements the Implementor interface.

Bridge in Action: Remote Control

Let's make a remote control that works with different devices (TV, Radio). The remote is the abstraction, and the devices are the implementations.

Run this code to see how they connect:

interface Device {
  void powerOn();
  void powerOff();
  void setChannel(int channel);
}

class Tv implements Device {
  @Override
  public void powerOn() { System.out.println("TV is ON"); }
  @Override
  public void powerOff() { System.out.println("TV is OFF"); }
  @Override
  public void setChannel(int channel) { System.out.println("TV Channel: " + channel); }
}

class Radio implements Device {
  @Override
  public void powerOn() { System.out.println("Radio is ON"); }
  @Override
  public void powerOff() { System.out.println("Radio is OFF"); }
  @Override
  public void setChannel(int channel) { System.out.println("Radio Frequency: " + channel + " MHz"); }
}

abstract class RemoteControl {
  protected Device device;
  public RemoteControl(Device device) { this.device = device; }
  public abstract void togglePower();
  public abstract void changeChannel(int channel);
}

class BasicRemote extends RemoteControl {
  public BasicRemote(Device device) { super(device); }
  @Override
  public void togglePower() {
    if (device instanceof Tv) { // Simple example for illustration
      System.out.print("Basic Remote TV: ");
    } else if (device instanceof Radio) {
      System.out.print("Basic Remote Radio: ");
    }
    // In a real scenario, device would have a state
    // For simplicity, we just toggle based on a dummy state
    device.powerOn(); // or powerOff() based on state
  }
  @Override
  public void changeChannel(int channel) {
    System.out.print("Basic Remote: ");
    device.setChannel(channel);
  }
}

public class Main {
  public static void main(String[] args) {
    Device tv = new Tv();
    RemoteControl basicTvRemote = new BasicRemote(tv);
    basicTvRemote.togglePower();
    basicTvRemote.changeChannel(7);

    System.out.println("---");

    Device radio = new Radio();
    RemoteControl basicRadioRemote = new BasicRemote(radio);
    basicRadioRemote.togglePower();
    basicRadioRemote.changeChannel(98);
  }
}

Connecting Abstraction & Impl.

Here, RemoteControl is our abstraction, and Device is the implementor interface. Tv and Radio are concrete implementations.

We can combine any RemoteControl with any Device. This means we can add new remotes (e.g., an AdvancedRemote) or new devices (e.g., a Projector) independently!

Why Use Bridge?

The Bridge pattern brings significant advantages:

Decoupling: Abstraction and implementation can be extended independently.
Reduced Complexity: Avoids a combinatorial explosion of classes (e.g., BasicTvRemote, AdvancedTvRemote, BasicRadioRemote, etc.).
Increased Flexibility: You can change the implementation at runtime without affecting the client.

Pattern Power-Up

You're designing a graphical user interface where elements can be individual buttons or panels containing other buttons and panels. Which design pattern is best suited to treat both individual buttons and panels uniformly?

Composite & Bridge Summary

Great job! You've explored two powerful structural patterns:

The Composite pattern simplifies client code by treating individual objects and groups of objects uniformly in a hierarchy.
The Bridge pattern decouples an abstraction from its implementation, allowing them to evolve independently and reducing complexity.

These patterns are crucial for building flexible and maintainable software systems. Keep practicing!

Perguntas Frequentes

A aula “Padrões Composto e Ponte” é grátis?

Sim — o texto completo de “Padrões Composto e Ponte” é 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 “Padrões Composto e Ponte”?

Trabalhe com o Composto para criar estruturas semelhantes a árvores e com a Ponte para desacoplar a abstração da implementação. 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 3 de 4.

Quanto tempo leva a aula “Padrões Composto e Ponte”?

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

Padrões Adaptador e Decorador
Padrões Fachada e Proxy
Padrões Composto e Ponte
Padrão Flyweight para eficiência de memória

← Voltar para Clean Architecture & Design Patterns in Practice