【结构型】树形结构的应用王者，组合模式

在日常开发中，我们往往忽视了设计模式的重要性。这可能是因为项目时间紧迫，或者对设计模式理解不深。其实，很多时候我们可能在不经意间已经使用了某些模式。

重要的是要有意识地学习和应用，让代码更加优雅和高效。也许是时候重新审视我们的编程实践，将设计模式融入其中了。

今天由浅入深，重学【组合模式】，让我们一起「重学设计模式」。

一、组合模式

1、组合模式是什么？

组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构来表示「部分-整体」的层次结构。组合模式使得用户可以像使用单个对象一样使用对象组合，简化了复杂结构的处理。

2、组合模式的主要参与者：

1. Component（抽象组件）：定义了对象的接口，所有组合对象和叶子节点都应实现它。

2. Leaf（叶子节点）：表示没有子节点的对象，即树的末端。

3. Composite（组合对象）：表示拥有子节点的对象。它不仅实现了 Component 接口，还能够存储并管理其子节点。

二、优化案例：文件系统

文件系统是组合模式的经典案例。文件系统中的文件夹可以包含文件或其他文件夹。无论是文件还是文件夹，它们都应该有一些共同的行为，例如显示名称或计算大小。

1、不使用组合模式

如果不采用组合模式，代码将需要分别处理叶子节点（如文件）和组合对象（如文件夹），这会导致代码复杂性增加。没有统一的接口意味着文件和文件夹需要不同的处理逻辑，导致代码的重复和不易扩展。

每次添加新的文件类型或子文件夹时，都需要修改已有代码，增加文件和文件夹的处理逻辑，代码会变得难以维护和扩展。

1. 冗余代码 ：Folder 类中有两个集合，一个存储文件，另一个存储子文件夹。由于没有通用接口，必须为文件和文件夹分别编写逻辑。

2. 缺乏一致性 ：要操作文件和文件夹时，必须分别对待。例如，showDetails() 方法中，文件和文件夹需要分开处理，无法将它们统一成一个对象。

3. 扩展性差 ：如果将来想要添加新的类型，比如符号链接、压缩文件等，必须分别为它们定义类，并在每个相关的逻辑中添加处理它们的代码。

public classFile{
private String name;
privateint size;
publicFile(String name, int size){
this.name = name;
this.size = size;
}
publicvoidshowDetails(){
System.out.println("File: " + name + " (Size: " + size + " KB)");
}
}
public classFolder{
private String name;
private List<File> files = new ArrayList<>();
private List<Folder> subFolders = new ArrayList<>();
publicFolder(String name){
this.name = name;
}
publicvoidaddFile(File file){
files.add(file);
}
publicvoidaddFolder(Folder folder){
subFolders.add(folder);
}
publicvoidshowDetails(){
System.out.println("Folder: " + name);
// 显示文件夹中的文件
for (File file : files) {
file.showDetails();
}
// 递归显示子文件夹中的内容
for (Folder folder : subFolders) {
folder.showDetails();
}
}
}
public classTest{
publicstaticvoidmain(String[] args){
File file1 = new File("Document.txt", 50);
File file2 = new File("Photo.jpg", 200);
Folder folder = new Folder("MyFolder");
folder.addFile(file1);
folder.addFile(file2);

File file3 = new File("test0.txt", 50);
File file4 = new File("test1.jpg", 200);
Folder folderRoot = new Folder("MyFolderRoot");
folderRoot.addFile(file3);
folderRoot.addFile(file4);
folderRoot.addFolder(folder);
folderRoot.showDetails();
}
}

















2、通过组合模式优化上面代码

在电子商务网站的产品目录中，可以通过组合模式管理产品和产品类别。每个产品（叶子节点）具有价格和描述，产品类别（组合对象）可以包含其他类别或产品。通过使用组合模式，可以简化查询价格、库存和类别层次的操作。

优化点：

1. 简化层次结构：在系统中，产品与类别都遵循相同的接口，可以统一处理产品和类别。

2. 灵活性：可以动态地增加或移除产品和类别，提高系统的可扩展性和维护性。

这个模式特别适合应用于具有递归或树形结构的场景。

文件和文件夹可以看作统一的组件，处理逻辑一致，新增类型时只需实现抽象接口，原有代码不需要修改。

/**
 * 抽象组件
 */
publicabstract classFileSystemComponent{
publicabstractvoidshowDetails();
}
/**
 * 叶子节点：文件
 */
public classFileextendsFileSystemComponent{
private String name;
privateint size;
publicFile(String name, int size){
this.name = name;
this.size = size;
}
@Override
publicvoidshowDetails(){
System.out.println("File: " + name + " (Size: " + size + " KB)");
}
}
/**
 * 组合对象：文件夹
 */
public classFolderextendsFileSystemComponent{
private String name;
private List<FileSystemComponent> components = new ArrayList<>();
publicFolder(String name){
this.name = name;
}
publicvoidaddComponent(FileSystemComponent component){
components.add(component);
}
@Override
publicvoidshowDetails(){
System.out.println("Folder: " + name);
for (FileSystemComponent component : components) {
component.showDetails();
}
}
}
public classCombinationClient{
publicstaticvoidmain(String[] args){
FileSystemComponent file1 = new File("Document.txt", 50);
FileSystemComponent file2 = new File("Photo.jpg", 200);
Folder folder = new Folder("MyFolder");
folder.addComponent(file1);
folder.addComponent(file2);
File file3 = new File("test0.txt", 50);
File file4 = new File("test1.jpg", 200);
Folder folderRoot = new Folder("MyFolderRoot");
folderRoot.addComponent(file3);
folderRoot.addComponent(file4);
folderRoot.addComponent(folder);
folderRoot.showDetails();
}
}
















三、使用组合模式有哪些优势

1、统一接口，简化客户端代码

组合模式为对象和对象组合提供了统一的接口，客户端可以一致地操作单个对象和组合对象，而不必区分它们是叶子还是组合。这种一致性减少了处理不同类型对象的复杂度，简化了代码。

2、递归结构处理方便

组合模式特别适合处理树形或递归结构，如文件系统、组织结构等。通过递归调用，可以轻松遍历整个结构（无论是文件还是文件夹），不必写不同的处理逻辑。

3、易扩展

新增叶子节点或组合对象时，只需实现相同的接口，不需要修改已有的代码。组合模式具有开放-封闭原则的优势，使系统更加灵活、易于扩展。

4、简化客户端操作

客户端不再需要关心对象的具体类型（叶子或组合），只需处理抽象组件。这使得代码更加简洁，也减少了错误处理的复杂性。

5、动态组合灵活

通过组合模式，可以动态地组合对象，而无需预先定义复杂的类结构。这为复杂对象提供了灵活的处理方式，使得系统结构更具弹性。

四、适用场景

1. 树形结构（层次结构） ：组合模式非常适用于需要表示「部分-整体」关系的场景，尤其是树形结构。例如，文件系统、组织结构图、产品目录树、菜单系统等。

五、组合模式的劣势

虽然组合模式有很多优势，但它也有一些潜在的劣势：

1. 过度抽象 ：为了实现通用接口，可能导致系统设计过于抽象和复杂，尤其是在层次结构非常深的情况下，增加了理解和维护的难度。

2. 性能问题 ：由于组合模式需要递归处理对象结构，在大规模、深层次的树形结构中，递归操作可能带来性能问题。

3. 类型安全问题 ：组合模式统一了叶子节点和组合对象的接口，有时可能难以强制类型检查。例如，某些操作只对叶子节点有效，调用这些操作时可能需要额外的类型判断。

六、在jdk源码中，哪些地方应用了组合模式，代码举例说明一下

在JDK源码中，组合模式被广泛应用于处理树形或层次结构的数据结构和设计，最典型的例子之一是 java.awt 包中的 Component 类，以及集合框架中的 java.util 包。

以下是两个常见的应用场景：

1、AWT（Abstract Window Toolkit）中的组件树

在 java.awt 包中，Component 类和 Container 类使用了组合模式。Container 代表可以包含子组件的对象，而 Component 是一个抽象组件，代表所有的 GUI 元素。Container 既可以是单个组件（叶子），也可以是组合组件（容器），从而形成了一个树形的 GUI 组件层次结构。

（1）代码分析：

1. Component 类是所有 GUI 元素的基类。

2. Container 类是 Component 的子类，它可以包含多个子组件。

（2）JDK 源码中的示例（简化）：

// java.awt.Component
publicabstract classComponent{
// 省略大量方法
publicvoidpaint(Graphics g){
// 绘制组件的代码
}
}
// java.awt.Container
public classContainerextendsComponent{
// 存储子组件
private List<Component> componentList = new ArrayList<>();
publicvoidadd(Component comp){
componentList.add(comp);
}
publicvoidremove(Component comp){
componentList.remove(comp);
}
@Override
publicvoidpaint(Graphics g){
super.paint(g);
// 递归调用子组件的 paint 方法
for (Component comp : componentList) {
comp.paint(g);
}
}
}




（3）组合模式分析：

1. Component 是一个抽象类，定义了所有组件的通用接口。

2. Container 是一个组合对象，包含其他组件，并可以递归地管理和绘制这些组件。

3. 在使用时，GUI 系统可以统一处理 Component 对象，不论它是叶子组件（如按钮、文本框），还是组合组件（如面板、窗口）。

2、集合框架中的 java.util 包

在 Java 集合框架中，List、Set、Map 等接口也使用了组合模式。集合类中既有可以直接存储元素的类（如 ArrayList、HashSet），也有可以组合其他集合的类（如 Collections.unmodifiableList、Collections.synchronizedList 等）。

（1）代码分析：

1. List 接口是所有列表的通用接口。

2. ArrayList 实现了 List 接口，代表叶子节点，可以直接存储元素。

3. Collections.unmodifiableList 通过组合模式，将一个已有的列表封装起来，实现不可修改的列表。

（2）JDK 源码中的示例：

// java.util.List (接口)
publicinterfaceList<E> extendsCollection<E> {
// 定义列表的通用方法
booleanadd(E e);
E get(int index);
// 省略其他方法
}
// java.util.ArrayList (叶子节点)
public classArrayList<E> extendsAbstractList<E> implementsList<E> {
private Object[] elementData;
privateint size;
publicArrayList(){
elementData = new Object[10];
}
@Override
publicbooleanadd(E e){
// 添加元素的逻辑
elementData[size++] = e;
returntrue;
}
@Override
public E get(int index){
return (E) elementData[index];
}
// 省略其他方法
}
// java.util.Collections.unmodifiableList (组合对象)
publicstatic <T> List<T> unmodifiableList(List<? extends T> list){
returnnew UnmodifiableList<>(list);
}
// 内部类，包装一个已有的 List
privatestatic classUnmodifiableList<E> extendsAbstractList<E> {
privatefinal List<? extends E> list;
UnmodifiableList(List<? extends E> list) {
this.list = Objects.requireNonNull(list);
}
@Override
public E get(int index){
return list.get(index);
}
@Override
publicbooleanadd(E e){
thrownew UnsupportedOperationException();
}
}









（3）组合模式分析：

1. List 接口是抽象组件，定义了所有列表操作的通用方法。

2. ArrayList 是具体的叶子节点，可以直接存储和操作元素。

3. UnmodifiableList 是一个组合对象，它通过包装另一个 List 实现不可修改的列表，并且与其他 List 一样实现了 List 接口。

4. List 和 ArrayList 之间的关系符合组合模式：ArrayList 作为叶子节点实现了通用的 List 接口，而 UnmodifiableList 通过组合其他列表来扩展功能，形成了一个树形的结构。

3、小总结

组合模式在 JDK 中的应用主要体现在处理层次结构、递归结构的场景。AWT 中的 Component 和 Container 类，集合框架中的 List 接口及其实现，都采用了组合模式。通过这种设计，Java 提供了灵活而统一的接口，简化了对复杂对象结构的处理，同时保持了系统的可扩展性。

七、总结

组合模式（Composite Pattern）是一种结构型设计模式，适用于将对象组合成树形结构来表示「部分-整体」的层次关系。它允许用户像使用单个对象一样操作对象组合，简化了复杂结构的处理。组合模式的主要参与者包括抽象组件（Component），叶子节点（Leaf），和组合对象（Composite）。每个组件通过统一接口，支持递归处理子节点，使得系统更加灵活、易扩展。

以文件系统为例，文件夹可以包含文件或其他文件夹。在不使用组合模式时，文件和文件夹必须分别处理，导致代码复杂性增加且扩展性差。通过组合模式，可以使用统一的接口管理文件和文件夹，简化层次结构并增强系统的扩展性和灵活性。

组合模式在JDK源码中有广泛应用，如 java.awt 中的组件树（Component 和 Container 类），以及集合框架中的 List、ArrayList 和 Collections.unmodifiableList。这些类通过组合模式处理递归结构和对象组合，使得操作统一、灵活。

- EOF -

推荐阅读 点击标题可跳转

如何使用 ChatGPT o1-mini

谷歌浏览器访问：https://www.nezhasoft.cn

回复gpt，获取ChatGPT4o、 o1-mini 直接使用地址

点击阅读原文，国内直接使用ChatGpt4o、o1-mini