组合与桥接模式
使用组合模式处理树形结构，并通过桥接模式解耦抽象与实现。
组合与桥接模式 是 CoddyKit 上的免费 Clean Architecture & Design Patterns in Practice 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 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
Implementorobject. - 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
Implementorinterface.
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!
常见问题解答
「组合与桥接模式」课时是免费的吗？
是的 — 「组合与桥接模式」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Clean Architecture & Design Patterns in Practice 课程的其余内容，请升级到 CoddyKit PRO。 Clean Architecture & Design Patterns in Practice 课程共包含 4 节课。
「组合与桥接模式」这节课中我会学到什么？
使用组合模式处理树形结构，并通过桥接模式解耦抽象与实现。 你通过在浏览器中直接运行的动手代码来练习 Clean Architecture & Design Patterns in Practice，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Clean Architecture & Design Patterns in Practice 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Clean Architecture & Design Patterns in Practice 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「组合与桥接模式」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Clean Architecture & Design Patterns in Practice 课中编写并运行代码吗？
能。每节 Clean Architecture & Design Patterns in Practice 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。