The Problem: Recursive Complexity
Imagine building a file system. You have Files and you have Folders. A Folder can contain Files, but it can also contain other Folders. If your code treats Files and Folders differently, you’ll end up with a mess of if (item is Folder) checks everywhere.
The Solution: The Composite Pattern
The Composite pattern allows you to compose objects into tree structures and then work with these structures as if they were individual objects.
How It Works:
- Component Interface: Defines the operations (e.g.,
getSize()) for both simple and complex objects. - Leaf (File): Implements the basic behavior.
- Composite (Folder): Stores a list of children and delegates the operations to them.
Why “God-Like”?
This pattern is incredibly powerful because it is recursive. You can build a hierarchy as deep as you want, and your client code doesn’t need to care if it’s talking to a single pixel or a whole 10,000-object group.
Real-World Example: UI Frameworks
Almost every modern UI framework (React, Flutter, Android) uses the Composite pattern. Every “View” can be a single button or a “Layout” containing 50 buttons. The layout renders itself by asking its children to render themselves.
References & Further Reading
- Refactoring Guru: Composite Pattern Design
- GoF Patterns: The Original Definition
- SourceMaking: Structural Patterns