Java Composition：组合模式在实际项目中的应用

组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构来表示“部分-整体”的层次结构。组合模式使得客户端可以统一地处理单个对象和对象的组合。

在实际项目中，组合模式有多种应用场景，以下是一些典型的例子：

1. 文件系统

在文件系统中，文件夹（Directory）可以包含文件（File）和其他文件夹（Directory）。使用组合模式，可以将文件和文件夹视为同一类型的对象，从而简化客户端代码。

// 组件接口
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> components = new ArrayList<>();

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

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

    public void remove(FileSystemComponent component) {
        components.remove(component);
    }

    @Override
    public void display() {
        System.out.println("Directory: " + name);
        for (FileSystemComponent component : components) {
            component.display();
        }
    }
}

2. GUI组件

在图形用户界面（GUI）中，窗口（Window）可以包含按钮（Button）、文本框（TextBox）和其他窗口（Window）。使用组合模式，可以将这些组件视为同一类型的对象，从而简化GUI框架的设计。

// 组件接口
interface GUIComponent {
    void render();
}

// 叶子节点（按钮）
class Button implements GUIComponent {
    private String label;

    public Button(String label) {
        this.label = label;
    }

    @Override
    public void render() {
        System.out.println("Rendering button: " + label);
    }
}

// 组合节点（面板）
class Panel implements GUIComponent {
    private List<GUIComponent> components = new ArrayList<>();
    private String name;

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

    public void add(GUIComponent component) {
        components.add(component);
    }

    public void remove(GUIComponent component) {
        components.remove(component);
    }

    @Override
    public void render() {
        System.out.println("Rendering panel: " + name);
        for (GUIComponent component : components) {
            component.render();
        }
    }
}

3. 组织结构

在公司或组织中，员工（Employee）可以包含经理（Manager）和其他员工（Employee）。使用组合模式，可以将员工和经理视为同一类型的对象，从而简化组织结构的管理。

// 组件接口
interface Employee {
    void display();
}

// 叶子节点（普通员工）
class RegularEmployee implements Employee {
    private String name;

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

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

// 组合节点（经理）
class Manager implements Employee {
    private String name;
    private List<Employee> subordinates = new ArrayList<>();

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

    public void addSubordinate(Employee employee) {
        subordinates.add(employee);
    }

    public void removeSubordinate(Employee employee) {
        subordinates.remove(employee);
    }

    @Override
    public void display() {
        System.out.println("Manager: " + name);
        for (Employee subordinate : subordinates) {
            subordinate.display();
        }
    }
}

4. 内容管理系统（CMS）

在内容管理系统中，页面（Page）可以包含文章（Article）、图片（Image）和其他页面（Page）。使用组合模式，可以将这些内容视为同一类型的对象，从而简化CMS的设计。

// 组件接口
interface Content {
    void display();
}

// 叶子节点（文章）
class Article implements Content {
    private String title;
    private String body;

    public Article(String title, String body) {
        this.title = title;
        this.body = body;
    }

    @Override
    public void display() {
        System.out.println("Article: " + title);
        System.out.println(body);
    }
}

// 组合节点（页面）
class Page implements Content {
    private String title;
    private List<Content> contents = new ArrayList<>();

    public Page(String title) {
        this.title = title;
    }

    public void addContent(Content content) {
        contents.add(content);
    }

    public void removeContent(Content content) {
        contents.remove(content);
    }

    @Override
    public void display() {
        System.out.println("Page: " + title);
        for (Content content : contents) {
            content.display();
        }
    }
}

总结

组合模式在实际项目中有很多应用场景，它通过将对象组合成树形结构来表示“部分-整体”的层次结构，使得客户端可以统一地处理单个对象和对象的组合。这种模式在文件系统、GUI组件、组织结构和内容管理系统等领域都有广泛的应用。