Composite Pattern: One size() Call for a File or Ten Thousand

Someone asks a simple question: how big is this folder? You start writing the answer and it stops being simple. A folder holds files, sure — but it also holds folders, which hold folders, which hold files. So your size() function grows a shape it hates: if (node is a file) return its bytes; else if (node is a folder) loop over its contents and for each one... ask the same question again. The branch on “is this a file or a folder?” leaks into every operation you write — size, search, render, delete — and each one re-derives the same tree walk with its own type check.

The pain isn’t the recursion. Recursion is fine. The pain is that the client — the code totalling the size, drawing the tree, zipping the archive — has to know the difference between a leaf and a container, and fork its logic on that difference, everywhere. A tree of a thousand nodes forces a thousand-node walk written by hand at every call site.

The intuition: a folder is just a thing with a size

Stop thinking of files and folders as two kinds of thing. Think of them as one kind of thing — a node — that happens to answer one question: “what’s your size?” A file answers with its own byte count. A folder answers by asking each of its children the same question and adding up the replies. Some of those children are files; some are folders that will recurse again. The folder doesn’t care which, because both are just nodes that can report a size.

That’s the whole trick. The moment “file” and “folder” share one interface, the caller stops branching. node.size() works whether node is a single 512-byte file or the root of your entire home directory. The recursion still happens — but it now lives inside the tree, in how a folder defines its own size(), not inside your client code as a type check you rewrite every time.

The members-only continuation builds the whole thing out: the three-role structure diagram, the runnable Component/Leaf/Composite code, a hierarchy assembled and called like a leaf, the transparent-vs-safe interface tradeoff, real-world Composite trees, the performance trap of a one-line O(n) walk, and an interview corner with a coding challenge and a quiz.