Clean Architecture & Design Patterns in Practice · Leçon

Modèles composite et pont

Travaillez avec le composite pour les structures arborescentes et avec le pont pour découpler l'abstraction de l'implémentation.

Modèles composite et pont est une leçon Clean Architecture & Design Patterns in Practice gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Clean Architecture & Design Patterns in Practice, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Clean Architecture & Design Patterns in Practice comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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!

Questions Fréquemment Posées

La leçon « Modèles composite et pont » est-elle gratuite ?

Oui — le texte complet de « Modèles composite et pont » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Clean Architecture & Design Patterns in Practice, passe à CoddyKit PRO. Le cours Clean Architecture & Design Patterns in Practice comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèles composite et pont » ?

Travaillez avec le composite pour les structures arborescentes et avec le pont pour découpler l'abstraction de l'implémentation. Tu pratiques Clean Architecture & Design Patterns in Practice avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Clean Architecture & Design Patterns in Practice ?

Aucune expérience préalable n'est requise. Clean Architecture & Design Patterns in Practice sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Modèles composite et pont » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Clean Architecture & Design Patterns in Practice ?

Oui. Chaque leçon Clean Architecture & Design Patterns in Practice inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Modèles adaptateur et décorateur
Modèles façade et proxy
Modèles composite et pont
Modèle Flyweight pour optimiser la mémoire

← Retour à Clean Architecture & Design Patterns in Practice