Composite Pattern

Description

Composite is the structural pattern for trees where a group should behave like a single item: a folder and a file both answer "what's your size?", a bundle and a product both answer "what's your price?". Leaves and groups share one interface, and a group answers by asking its children - so client code never checks which one it's holding. This skill covers the pattern, how the recursion works, and how to keep a tree a tree.

A file system has files and folders, and folders contain files and other folders. Computing the size of a folder without a plan looks like this:

long size(Object node) {
    if (node instanceof File f) return f.bytes();
    long total = 0;
    for (Object child : ((Folder) node).children()) {
        total += size(child);             // every operation needs this same type-check dance
    }
    return total;
}

def size(node) -> int:
    if isinstance(node, File):
        return node.bytes
    total = 0
    for child in node.children:
        total += size(child)             # every operation needs this same type-check dance
    return total

Every operation - size, count, search, print - repeats the same instanceof checks and casts. Add a new kind of node (a symbolic link, a zip archive) and you must update every one of them.

We'll go from simple to more technical:

1. The pattern: one interface for leaves and composites.
2. How the recursion works, step by step.
3. Where you'll see composites: UI trees, menus, bundles, expression trees.
4. Keeping trees safe - cycles, depth and where add() belongs - and choosing among the structural patterns.

The pattern

Composite gives single items (leaves) and groups (composites) the same interface, so clients treat them uniformly. A composite implements each operation by delegating to its children.

interface Node {
    String name();
    long size();
}

class FileNode implements Node {
    private final String name;
    private final long bytes;
    FileNode(String name, long bytes) { this.name = name; this.bytes = bytes; }
    public String name() { return name; }
    public long size() { return bytes; }
}

class FolderNode implements Node {
    private final String name;
    private final List<Node> children = new ArrayList<>();
    FolderNode(String name) { this.name = name; }
    void add(Node child) { children.add(child); }
    public String name() { return name; }
    public long size() {
        long total = 0;
        for (Node child : children) total += child.size();   // no type checks - each child knows its own size
        return total;
    }
}

from abc import ABC, abstractmethod


class Node(ABC):
    def __init__(self, name: str):
        self.name = name

    @abstractmethod
    def size(self) -> int: ...


class FileNode(Node):
    def __init__(self, name: str, size_bytes: int):
        super().__init__(name)
        self._size_bytes = size_bytes

    def size(self) -> int:
        return self._size_bytes


class FolderNode(Node):
    def __init__(self, name: str):
        super().__init__(name)
        self._children: list[Node] = []

    def add(self, child: Node) -> None:
        self._children.append(child)

    def size(self) -> int:
        return sum(child.size() for child in self._children)   # no type checks

How it works, step by step

1. Define one component interface for everything in the tree (Node).
2. Leaves implement it directly (FileNode.size() returns its bytes).
3. Composites hold a list of components and implement each operation by combining their children's results.
4. Because children are also Nodes, the recursion happens naturally - no instanceof anywhere.
5. Clients call size() on any node, file or folder, the same way.

Where you'll see it

• UI toolkits: a Swing JPanel (a container) holds buttons and other panels; the browser DOM works the same way.
• React/Angular component trees.
• Organization charts, menus with sub-menus, and product bundles that contain other bundles.
• Expression trees in compilers: (1 + (2 * 3)) is a tree of operations and numbers.

Choosing among the structural patterns

Common mistakes

Check yourself

Try to answer before opening each one - recalling beats re-reading.

1. How does a folder's size() work without any instanceof checks?

2. Transparency vs. safety: where would you put add(child), and what does each choice cost?

3. How can add(child) refuse to create a cycle?

Key takeaways

• Leaves and groups share one interface, so clients treat them the same way.
• A composite implements each operation by combining its children's results - recursion without instanceof.
• Protect the tree: prevent cycles, and beware of very deep recursion.
• Decide deliberately where child-management methods live (transparency vs. safety).
• Think file systems, UI containers, menus, bundles and expression trees.