Composite Pattern

Definition

The Composite Pattern is a structural design pattern that composes objects into tree structures to represent part-whole hierarchies, letting clients treat individual objects and compositions of objects through the same uniform interface.

Overview

The Composite Pattern solves the problem of needing to treat single objects and groups of objects identically when working with recursive, tree-shaped data. It defines a common interface (often called Component) that both leaf objects (individual elements with no children) and composite objects (containers that hold child components, which may themselves be leaves or further composites) implement. Because both leaves and composites share the same interface, client code can call the same methods — such as `render()`, `getSize()`, or `draw()` — on either a single leaf or an entire subtree, and the composite simply delegates the call recursively to its children, aggregating or forwarding results as appropriate. The canonical example is a file system, where files (leaves) and directories (composites containing files and other directories) both need to support operations like calculating total size or displaying a name, and client code shouldn't need to distinguish between the two when performing those operations. Graphics editors use the same pattern for grouping shapes — a "group" object containing multiple shapes behaves just like a single shape when moved, resized, or rendered. GUI frameworks build entire widget trees this way: a panel containing buttons and other panels responds to layout and paint operations exactly like an individual widget would, which is why the Composite Pattern underlies most GUI toolkits' scene-graph or view-hierarchy designs. Composite is frequently used alongside other patterns from the Gang of Four catalog: Visitor is commonly layered on top of a composite tree to add new operations without modifying the component classes, Iterator provides ways to traverse the tree, and Decorator can wrap individual components to add behavior. The main design tension in implementing Composite is deciding how much of the composite-specific interface (like `add()`/`remove()` for managing children) should be exposed on the shared Component interface versus kept only on the Composite subclass — exposing it uniformly simplifies client code but risks leaf objects inheriting meaningless operations, while restricting it to composites is more type-safe but requires clients to distinguish leaf from composite in some cases.

Key Concepts

• Defines a uniform interface shared by leaf and composite (container) objects
• Models recursive, tree-shaped part-whole hierarchies
• Client code treats single objects and groups of objects identically
• Composite objects delegate operations recursively to their children
• Canonical example: file systems with files (leaves) and directories (composites)
• Underlies GUI widget/scene-graph hierarchies and rendering trees
• Frequently combined with Visitor and Iterator patterns
• Design tension: whether to expose child-management methods on the shared interface

Use Cases

Frequently Asked Questions

Related in Programming