组合模式是一种常用的结构型设计模式，它允许我们将对象组合成树形结构来表达“整体-部分”的关系。在现实世界中，很多对象都可以分解为更小的对象，并且这些小对象可能又可以分解为更小的对象。在这种情况下，我们需要一种灵活而高效的方式来组合这些对象，并且能够轻松地遍历和操作它们。

组合模式正是为了解决这个问题而诞生的，它可以将叶子节点和组合节点统一视为“组件”，并将它们组合成一棵树形结构。这样，我们就可以通过统一的方式来操作整个树形结构，而不需要考虑具体的节点类型和层次。

基本概念

什么是组合模式

组合模式是一种结构型设计模式，它将对象组合成树形结构以表示“整体-部分”的层次结构。组合模式允许客户端统一处理单个对象和对象组合，从而简化了客户端的代码逻辑。

组成部分：叶子节点和组合节点

在组合模式中，有两种基本的节点类型：叶子节点和组合节点。

• 叶子节点：表示树形结构中的最小节点，没有子节点。叶子节点只能进行基本操作，如获取属性、调用方法等。
• 组合节点：表示树形结构中的非叶子节点，有一个或多个子节点。组合节点可以进行基本操作，也可以递归调用其子节点的操作。

树形结构

组合模式中的节点被组织成树形结构，树形结构有一个根节点和零个或多个子节点。节点之间的关系可以表示为“整体-部分”的关系，即父节点是其子节点的容器。

实现方法

在组合模式中，需要定义抽象组件类、叶子组件类和组合组件类三种基本类别。

• 抽象组件类(Component)：定义所有叶子节点和组合节点共有的方法和属性。
• 叶子组件类(Leaf)：实现叶子节点的特有方法。
• 组合组件类(Composite)：实现组合节点的特有方法，并定义一个集合用于存储其子节点。

安全组合模式和透明组合模式

组合模式分为安全组合模式和透明组合模式两种实现方式。

安全组合模式中，抽象组件类只定义了叶子节点和组合节点共有的方法，叶子节点和组合节点分别继承抽象组件类并实现各自特有的操作。

透明组合模式中，抽象组件类定义了所有节点共有的方法和属性，并提供了默认的实现，叶子节点和组合节点都继承抽象组件类并实现各自特有的操作。

代码实现

生活中的例子可以是一个文件系统，文件系统中的文件和文件夹可以组合成一棵树形结构。在这个树形结构中，每个文件可以是一个叶子节点，而每个文件夹可以是一个组合节点。每个组合节点可以包含一个或多个文件或文件夹。

使用组合模式，我们可以方便地管理和操作整个文件系统。例如，我们可以遍历整个文件系统并列出所有的文件和文件夹，或者只列出某个文件夹下的文件和文件夹。我们还可以添加或删除文件或文件夹，而不需要考虑具体的节点类型和层次。这样，我们就可以使用统一的方式来处理整个文件系统，并且使代码更加简洁和易于维护。

import java.util.ArrayList;
import java.util.List;

// 抽象组件类
abstract class Component {
    protected String name;
    
    public Component(String name) {
        this.name = name;
    }
    
    public abstract void add(Component component);
    public abstract void remove(Component component);
    public abstract void display();
}

// 叶子节点类
class File extends Component {
    public File(String name) {
        super(name);
    }
    
    public void add(Component component) {
        System.out.println("Cannot add to a file.");
    }
    
    public void remove(Component component) {
        System.out.println("Cannot remove from a file.");
    }
    
    public void display() {
        System.out.println(name);
    }
}

// 组合节点类
class Folder extends Component {
    private List<Component> children = new ArrayList<Component>();
    
    public Folder(String name) {
        super(name);
    }
    
    public void add(Component component) {
        children.add(component);
    }
    
    public void remove(Component component) {
        children.remove(component);
    }
    
    public void display() {
        System.out.println(name);
        for (Component component : children) {
            component.display();
        }
    }
}

// 客户端类
public class FileSystemDemo {
    public static void main(String[] args) {
        Component root = new Folder("root");
        Component file1 = new File("file1");
        Component file2 = new File("file2");
        Component folder1 = new Folder("folder1");
        Component file3 = new File("file3");
        Component folder2 = new Folder("folder2");
        Component file4 = new File("file4");
        
        root.add(file1);
        root.add(file2);
        root.add(folder1);
        folder1.add(file3);
        folder1.add(folder2);
        folder2.add(file4);
        
        root.display();
    }
}

上述示例中实现的是透明组合模式，而不是安全组合模式。在透明组合模式中，抽象组件类中定义了所有的子组件的操作，包括添加、删除、遍历等，这样所有的叶子节点和组合节点都可以使用相同的接口来进行操作。透明组合模式的优点是简单易用，但是它的缺点是可能会引入一些不必要的操作，例如在叶子节点中实现添加和删除操作。

与之相对的，安全组合模式将抽象组件类中只定义了叶子节点的操作，而将添加和删除操作移动到了具体的组合类中，这样可以避免不必要的操作，提高代码的安全性和可维护性。下面是一个使用安全组合模式的示例代码，其中我们将抽象组件类中只定义了叶子节点的操作：

import java.util.ArrayList;
import java.util.List;

// 抽象组件类
abstract class Component {
    protected String name;
    
    public Component(String name) {
        this.name = name;
    }
    
    public abstract void display();
}

// 叶子节点类
class File extends Component {
    public File(String name) {
        super(name);
    }
    
    public void display() {
        System.out.println(name);
    }
}

// 组合节点类
class Folder extends Component {
    private List<Component> children = new ArrayList<Component>();
    
    public Folder(String name) {
        super(name);
    }
    
    public void add(Component component) {
        children.add(component);
    }
    
    public void remove(Component component) {
        children.remove(component);
    }
    
    public void display() {
        System.out.println(name);
        for (Component component : children) {
            component.display();
        }
    }
}

// 客户端类
public class FileSystemDemo {
    public static void main(String[] args) {
        Component root = new Folder("root");
        Component file1 = new File("file1");
        Component file2 = new File("file2");
        Component folder1 = new Folder("folder1");
        Component file3 = new File("file3");
        Component folder2 = new Folder("folder2");
        Component file4 = new File("file4");
        
        root.add(file1);  // 报错，叶子节点不能添加子节点
        root.add(file2);  // 报错，叶子节点不能添加子节点
        root.add(folder1);
        folder1.add(file3);
        folder1.add(folder2);
        folder2.add(file4);
        
        root.display();
    }
}

总结

组合模式是一种灵活、高效、可扩展的设计模式，它可以帮助我们管理和操作复杂对象，并提高代码的可维护性和可读性。通过将对象组织成树形结构，我们可以将对象的层次结构清晰地表示出来，并使用统一的方式来操作这些对象。在实践中，组合模式可以应用于许多场景，例如文件系统、组织机构结构、菜单和导航栏等。通过学习本文，我们可以更好地理解组合模式的概念、实现方法和应用场景，并在实践中灵活运用这个重要的设计模式。