All 15 Design Patterns in Java questions
More in Design Patterns in Java
What is the Factory Method pattern, and how does it differ from the simpler Static Factory Method idiom (like List.of() or Optional.of())? What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself? How would you implement the Dependency Injection pattern manually (without a framework like Spring) using constructor injection, and what testability benefits does this provide? How would you implement the Visitor pattern in Java to add new operations to an existing class hierarchy without modifying those classes, and how do Java's sealed classes and pattern matching (switch expressions) provide a modern alternative? How would you use the Chain of Responsibility pattern to implement a request-processing pipeline (such as middleware-style validation/authentication/logging), and how does this relate conceptually to servlet filters or web framework middleware? How would you implement the Proxy pattern to add lazy initialization to an expensive-to-create object, and how does this differ structurally from the Decorator pattern despite both wrapping an object behind a shared interface?
Advertisement
Back to results for “File System”
Java › Design Patterns in Java

How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories?

Intermediate

Answer

Composite defines a common interface shared by both individual ("leaf") objects and composite ("container") objects that hold collections of the same interface type, letting client code treat a single object and a tree of nested objects uniformly through that shared interface -- a composite's operations (like calculating total size) typically recurse into its children, naturally handling arbitrarily deep nesting without the calling code needing to know whether it's dealing with a single leaf or an entire subtree.
public interface FileSystemNode { long getSize(); }

class File implements FileSystemNode {
    private final long size;
    public File(long size) { this.size = size; }
    public long getSize() { return size; }
}

class Directory implements FileSystemNode {
    private final List<FileSystemNode> children = new ArrayList<>();
    public void add(FileSystemNode node) { children.add(node); }
    public long getSize() {
        return children.stream().mapToLong(FileSystemNode::getSize).sum();  // recurses uniformly
    }
}
Real-world example A file system browser calculates the total size of a deeply nested directory tree by calling getSize() on the top-level Directory, which transparently recurses through every nested File and Directory via the shared FileSystemNode interface, without the calling code needing any special-case logic for files versus directories.

Common follow-ups: How does the Composite pattern handle operations that only make sense for one type (leaf or composite) but not the other?;What's the performance consideration of a Composite structure that's extremely deeply nested?

OOP & Classes;Interfaces & Abstract Classes
All 15 Design Patterns in Java questions