Clean Architecture & Design Patterns in Practice · درس

أنماط Composite وBridge

استخدم Composite للتعامل مع البنى الشجرية، وBridge لفصل التجريد عن التطبيق.

أنماط Composite وBridge درس مجاني في Clean Architecture & Design Patterns in Practice على CoddyKit. هذا هو الدرس 3 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في Clean Architecture & Design Patterns in Practice، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة Clean Architecture & Design Patterns in Practice 4 دروس في المجموع.

بعض أجزاء هذا الدرس لم تُترجم بعد وتظهر باللغة الإنجليزية.

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!

الأسئلة الشائعة

هل درس «أنماط Composite وBridge» مجاني؟

نعم — نص درس «أنماط Composite وBridge» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة Clean Architecture & Design Patterns in Practice، انتقل إلى CoddyKit PRO. تتضمن دورة Clean Architecture & Design Patterns in Practice 4 دروس في المجموع.

ماذا ستتعلم في «أنماط Composite وBridge»؟

استخدم Composite للتعامل مع البنى الشجرية، وBridge لفصل التجريد عن التطبيق. تتمرن على Clean Architecture & Design Patterns in Practice مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ Clean Architecture & Design Patterns in Practice؟

لا تُشترط خبرة سابقة. Clean Architecture & Design Patterns in Practice على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 3 من أصل 4.

كم من الوقت يستغرق درس «أنماط Composite وBridge»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس Clean Architecture & Design Patterns in Practice هذا؟

نعم. كل درس في Clean Architecture & Design Patterns in Practice يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

← العودة إلى Clean Architecture & Design Patterns in Practice