编辑“︁Java组合模式”︁

{{DISPLAYTITLE:Java组合模式}}  
'''组合模式'''（Composite Pattern）是[[设计模式]]中一种'''结构型模式'''，用于将对象组合成树形结构以表示“部分-整体”的层次关系。它允许客户端以统一的方式处理单个对象和组合对象，简化了复杂结构的操作。  

== 概述 ==  
组合模式的核心思想是通过一个'''抽象组件'''（Component）定义所有对象的通用行为，包括'''叶子节点'''（Leaf）和'''容器节点'''（Composite）。叶子节点表示不可再分的对象，而容器节点可以包含其他子组件（可能是叶子或其他容器）。  

=== 适用场景 ===  
* 需要表示对象的'''部分-整体层次结构'''（如文件系统、菜单树）。  
* 希望客户端忽略组合对象与单个对象的差异，统一调用接口。  

== 结构 ==  
组合模式的类图如下：  
<mermaid>  
classDiagram  
    class Component {  
        <<interface>>  
        +operation()  
        +add(Component)  
        +remove(Component)  
        +getChild(int)  
    }  
    class Leaf {  
        +operation()  
    }  
    class Composite {  
        -children: List<Component>  
        +operation()  
        +add(Component)  
        +remove(Component)  
        +getChild(int)  
    }  
    Component <|-- Leaf  
    Component <|-- Composite  
    Composite o-- Component  
</mermaid>  

* '''Component'''：抽象接口，定义所有组件的公共操作。  
* '''Leaf'''：叶子节点，无子组件，实现基础行为。  
* '''Composite'''：容器节点，存储子组件并实现与子组件相关的操作。  

== 代码示例 ==  
以下是一个文件系统的实现示例：  

<syntaxhighlight lang="java">  
// 抽象组件  
interface FileSystemComponent {  
    void display();  
}  

// 叶子节点：文件  
class File implements FileSystemComponent {  
    private String name;  

    public File(String name) {  
        this.name = name;  
    }  

    @Override  
    public void display() {  
        System.out.println("File: " + name);  
    }  
}  

// 容器节点：文件夹  
class Directory implements FileSystemComponent {  
    private String name;  
    private List<FileSystemComponent> children = new ArrayList<>();  

    public Directory(String name) {  
        this.name = name;  
    }  

    public void add(FileSystemComponent component) {  
        children.add(component);  
    }  

    @Override  
    public void display() {  
        System.out.println("Directory: " + name);  
        for (FileSystemComponent component : children) {  
            component.display(); // 递归调用子组件的display()  
        }  
    }  
}  

// 客户端代码  
public class CompositeDemo {  
    public static void main(String[] args) {  
        File file1 = new File("Document.txt");  
        File file2 = new File("Image.jpg");  

        Directory subDir = new Directory("SubFolder");  
        subDir.add(file2);  

        Directory rootDir = new Directory("Root");  
        rootDir.add(file1);  
        rootDir.add(subDir);  

        rootDir.display();  
    }  
}  
</syntaxhighlight>  

=== 输出 ===  
<pre>  
Directory: Root  
File: Document.txt  
Directory: SubFolder  
File: Image.jpg  
</pre>  

== 实际应用案例 ==  
1. '''GUI组件库'''：如Swing中的<code>JComponent</code>作为抽象组件，<code>JPanel</code>作为容器，<code>JButton</code>作为叶子节点。  
2. '''文件系统'''：如上述示例，文件夹和文件的层次结构。  
3. '''菜单系统'''：菜单项（叶子）和子菜单（容器）的统一处理。  

== 优缺点 ==  
{| class="wikitable"  
|+ 组合模式的优缺点  
|-  
! 优点 !! 缺点  
|-  
| 简化客户端代码，统一处理叶子与容器 || 可能违反[[单一职责原则]]（需同时管理子组件和自身逻辑）  
|-  
| 易于扩展新类型的组件 || 对树结构的限制较少，需谨慎设计递归逻辑  
|}  

== 数学表示 ==  
组合模式的结构可以形式化为树：  
<math>  
T = \begin{cases}  
\text{Leaf} & \text{若为叶子节点} \\  
\text{Composite} \cup \{T_1, T_2, \dots, T_n\} & \text{若为容器节点}  
\end{cases}  
</math>  

== 总结 ==  
组合模式通过树形结构统一处理简单和复杂对象，是处理层次化数据的强大工具。初学者应重点理解递归调用的逻辑，而高级用户可探索其在动态构建对象树（如XML解析）中的应用。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java设计模式]]