Composite Pattern: Treating Trees and Leaves Uniformly

// VIOLATION: File and Folder don't share an interface, so every caller
// has to know which one it's holding and branch accordingly.
class File {
    private final String name;
    private final long sizeBytes;
 
    File(String name, long sizeBytes) { this.name = name; this.sizeBytes = sizeBytes; }
    long getSize() { return sizeBytes; }
}
 
class Folder {
    private final String name;
    private final List<File> files = new ArrayList<>();
    private final List<Folder> subfolders = new ArrayList<>();
 
    Folder(String name) { this.name = name; }
    void addFile(File f) { files.add(f); }
    void addFolder(Folder f) { subfolders.add(f); }
 
    // Client has to recurse manually, and this method needs updating every
    // time a new "container-like" type is added to the file system model.
    long totalSize() {
        long total = 0;
        for (File f : files) total += f.getSize();
        for (Folder sub : subfolders) total += sub.totalSize(); // manual recursion
        return total;
    }
}
 
// Any OTHER client that wants to compute size (a search indexer, a backup tool)
// has to reimplement this same type-branching traversal itself.
long computeSizeExternally(Object item) {
    if (item instanceof File f) return f.getSize();
    if (item instanceof Folder folder) {
        long total = 0;
        for (File f : folder.getFiles()) total += f.getSize();
        for (Folder sub : folder.getSubfolders()) total += computeSizeExternally(sub);
        return total;
    }
    throw new IllegalArgumentException("unknown type");
}

// The shared interface — leaves and composites both honor this contract
interface FileSystemNode {
    String getName();
    long getSize();
}
 
// Leaf: no children, implements the operation directly
class File implements FileSystemNode {
    private final String name;
    private final long sizeBytes;
 
    File(String name, long sizeBytes) { this.name = name; this.sizeBytes = sizeBytes; }
 
    public String getName() { return name; }
    public long getSize() { return sizeBytes; }
}
 
// Composite: holds children of the SAME interface type, implements the
// operation by delegating to each child — recursion is automatic and hidden
class Folder implements FileSystemNode {
    private final String name;
    private final List<FileSystemNode> children = new ArrayList<>();
 
    Folder(String name) { this.name = name; }
 
    void add(FileSystemNode node) { children.add(node); } // could be a File OR a Folder
    void remove(FileSystemNode node) { children.remove(node); }
 
    public String getName() { return name; }
 
    public long getSize() {
        long total = 0;
        for (FileSystemNode child : children) {
            total += child.getSize(); // works whether child is a File or a Folder — no branching
        }
        return total;
    }
}

// Client code treats a single file and an entire tree identically:
Folder root = new Folder("project");
Folder src = new Folder("src");
src.add(new File("Main.java", 2_048));
src.add(new File("Utils.java", 1_024));
 
Folder docs = new Folder("docs");
docs.add(new File("README.md", 512));
 
root.add(src);
root.add(docs);
root.add(new File(".gitignore", 64));
 
// ONE call computes the total recursively — no branching, no manual traversal
System.out.println(root.getSize()); // 2048 + 1024 + 512 + 64 = 3648
 
// Any function that accepts FileSystemNode works on a leaf or an entire subtree:
void printSize(FileSystemNode node) {
    System.out.println(node.getName() + ": " + node.getSize());
}
printSize(root);                  // whole tree
printSize(src.getChildren().get(0)); // just one file — same method, same interface

// Option A: uniform interface, but File.add() must throw
interface FileSystemNode {
    String getName();
    long getSize();
    void add(FileSystemNode node);    // meaningless for File
    void remove(FileSystemNode node); // meaningless for File
}
 
class File implements FileSystemNode {
    // ...
    public void add(FileSystemNode node) {
        throw new UnsupportedOperationException("a file cannot contain children"); // LSP violation
    }
    public void remove(FileSystemNode node) {
        throw new UnsupportedOperationException("a file cannot contain children");
    }
}

// Option B: safe interface, generic client code needs a type check to mutate structure
interface FileSystemNode {
    String getName();
    long getSize();
}
 
class Folder implements FileSystemNode {
    void add(FileSystemNode node) { children.add(node); } // only exists here
    // ...
}
 
void addIfPossible(FileSystemNode parent, FileSystemNode child) {
    if (parent instanceof Folder folder) {
        folder.add(child); // type check needed — only Folder can accept children
    } else {
        throw new IllegalArgumentException(parent.getName() + " cannot contain children");
    }
}