设计模式之组合模式(composize)

写在前面

什么是组合模式，笼统来说，用来处理树形结构的模式就是组合模式

举几个树形结构的例子：

每一个文件和文件夹就是树的结点，具体的一个文件就是树的叶子节点

前段时间一个教育行业的同事遇到的一个问题

这也是一个树形结构，不过分类更加复杂一些，不像文件目录结构那样，只有两种类型：文件夹和文件

代码分析

这里以文件目录结构为例

抽象出树形结构的祖宗Node

package com.zl.composize;

public abstract class Node {
    public abstract void print();
    public abstract void add(Node node);
}

　　2. 叶子节点，代表文件

package com.zl.composize;

public class LeafNode extends Node{
    
    String content;
    public LeafNode(String content) {
        this.content = content;
    }
    
    @Override
    public void print() {
        System.out.println(content);
    }

    @Override
    public void add(Node node) {
        System.out.println("这是叶子结点，不能添加元素");
    }
}

　　3. 分支节点，代表文件夹（注意，当文件夹为空时，它就是一个叶子节点）

package com.zl.composize;

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

public class BranchNode extends Node{
    String name;
    public List<Node> nodes = new ArrayList<>();
    public BranchNode(String name) {
        this.name = name;
    }
    @Override
    public void print() {
        System.out.println(name);
    }
    @Override
    public void add(Node node) {
        nodes.add(node);
    }
}

　　4. 测试类Main

package com.zl.composize;

public class Main {
    public static void main(String[] args) {
        BranchNode root = new BranchNode("root");
        BranchNode branchNode1 = new BranchNode("1-1");
        BranchNode branchNode2 = new BranchNode("2-1");
        LeafNode leafNode1 = new LeafNode("1-1-1");
        LeafNode leafNode2 = new LeafNode("1-1-2");
        BranchNode branchNode3 = new BranchNode("2-1-1");
        LeafNode leafNode3 = new LeafNode("2-1-1-1");
        LeafNode leafNode4 = new LeafNode("2-1-1-2");

        root.add(branchNode1);
        root.add(branchNode2);
        branchNode1.add(leafNode1);
        branchNode1.add(leafNode2);
        branchNode2.add(branchNode3);
        branchNode3.add(leafNode3);
        branchNode3.add(leafNode4);

        tree(root, 0);
    }

    public static void tree(Node node, int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("--");
        }
        node.print();
        if (node instanceof BranchNode) {
            BranchNode branchNode = (BranchNode)node;
            for (Node branchNode1: branchNode.nodes)
                tree(branchNode1, depth+1);
        }
    }
}

为了更清晰的看出目录结构，递归输出时，我做了一些处理。输出结果如下：