Composite Pattern · Design Patterns

What is the Composite pattern?

Composite means: build a tree of objects — folders containing files, bundles containing products — and let a single leaf and a whole group answer the same calls through one shared interface.

A file and a folder both answer “what is your size?” A product and a gift set both answer “what is your price?” The caller never needs a special case for “is this a group?”

Two roles show up:

Leaf — an individual thing with no children (a file, a single item).
Composite — a thing that contains children, which may themselves be leaves or composites (a directory, a bundle).

Both implement the same component interface. A composite forwards operations to its children and combines the results.

The problem it solves

Without Composite, totaling a group of things often turns into type checks:

if isinstance(thing, Bundle):
    pass  # walk children
elif isinstance(thing, Item):
    pass  # use item price

if (thing instanceof Bundle) {
    // walk children
} else if (thing instanceof Item) {
    // use item price
}

switch t := thing.(type) {
case Bundle:
	_ = t // walk children
case Item:
	_ = t // use item price
}

if (thing instanceof Bundle) {
  // walk children
} else if (thing instanceof Item) {
  // use item price
}

Every new operation — print a label, apply a discount, export to JSON — risks another nest of type checks. Composite moves the branching into the objects themselves: leaves answer directly, groups ask their children.

A file-system example

class FileSystemComponent:
    def display(self, indent: str = "") -> None:
        raise NotImplementedError

    def get_size(self) -> int:
        raise NotImplementedError


class FileLeaf(FileSystemComponent):
    def __init__(self, name: str, size: int) -> None:
        self._name = name
        self._size = size

    def display(self, indent: str = "") -> None:
        print(f"{indent}File: {self._name} ({self._size} bytes)")

    def get_size(self) -> int:
        return self._size


class Directory(FileSystemComponent):
    def __init__(self, name: str) -> None:
        self._name = name
        self._children: list[FileSystemComponent] = []

    def add(self, component: FileSystemComponent) -> None:
        self._children.append(component)

    def display(self, indent: str = "") -> None:
        print(f"{indent}Dir: {self._name}")
        for child in self._children:
            child.display(indent + "  ")

    def get_size(self) -> int:
        return sum(child.get_size() for child in self._children)


# use
docs = Directory("docs")
docs.add(FileLeaf("readme.txt", 1200))
docs.add(FileLeaf("license.txt", 800))

root = Directory("project")
root.add(docs)
root.add(FileLeaf("app.jar", 50_000))

root.display()
print(f"Total size: {root.get_size()}")

public interface FileSystemComponent {
    void display(String indent);
    long getSize();
}

public class FileLeaf implements FileSystemComponent {
    private final String name;
    private final long size;

    public FileLeaf(String name, long size) {
        this.name = name;
        this.size = size;
    }

    @Override
    public void display(String indent) {
        System.out.println(indent + "File: " + name + " (" + size + " bytes)");
    }

    @Override
    public long getSize() {
        return size;
    }
}

public class Directory implements FileSystemComponent {
    private final String name;
    private final List<FileSystemComponent> children = new ArrayList<>();

    public Directory(String name) {
        this.name = name;
    }

    public void add(FileSystemComponent component) {
        children.add(component);
    }

    @Override
    public void display(String indent) {
        System.out.println(indent + "Dir: " + name);
        for (FileSystemComponent child : children) {
            child.display(indent + "  ");
        }
    }

    @Override
    public long getSize() {
        long total = 0;
        for (FileSystemComponent child : children) {
            total += child.getSize();
        }
        return total;
    }
}

// use
Directory docs = new Directory("docs");
docs.add(new FileLeaf("readme.txt", 1200));
docs.add(new FileLeaf("license.txt", 800));

Directory root = new Directory("project");
root.add(docs);
root.add(new FileLeaf("app.jar", 50_000));

root.display("");
System.out.println("Total size: " + root.getSize());

type FileSystemComponent interface {
	Display(indent string)
	Size() int
}

type FileLeaf struct {
	Name  string
	Bytes int
}

func (f FileLeaf) Display(indent string) {
	fmt.Printf("%sFile: %s (%d bytes)\\n", indent, f.Name, f.Bytes)
}

func (f FileLeaf) Size() int { return f.Bytes }

type Directory struct {
	Name     string
	children []FileSystemComponent
}

func (d *Directory) Add(component FileSystemComponent) {
	d.children = append(d.children, component)
}

func (d *Directory) Display(indent string) {
	fmt.Println(indent + "Dir: " + d.Name)
	for _, child := range d.children {
		child.Display(indent + "  ")
	}
}

func (d *Directory) Size() int {
	total := 0
	for _, child := range d.children {
		total += child.Size()
	}
	return total
}

// use
docs := &Directory{Name: "docs"}
docs.Add(FileLeaf{Name: "readme.txt", Bytes: 1200})
docs.Add(FileLeaf{Name: "license.txt", Bytes: 800})

root := &Directory{Name: "project"}
root.Add(docs)
root.Add(FileLeaf{Name: "app.jar", Bytes: 50_000})

root.Display("")
fmt.Println("Total size:", root.Size())

interface FileSystemComponent {
  display(indent: string): void;
  getSize(): number;
}

class FileLeaf implements FileSystemComponent {
  constructor(
    private name: string,
    private size: number,
  ) {}

  display(indent: string) {
    console.log(`${indent}File: ${this.name} (${this.size} bytes)`);
  }

  getSize() {
    return this.size;
  }
}

class Directory implements FileSystemComponent {
  private children: FileSystemComponent[] = [];

  constructor(private name: string) {}

  add(component: FileSystemComponent) {
    this.children.push(component);
  }

  display(indent: string) {
    console.log(`${indent}Dir: ${this.name}`);
    for (const child of this.children) {
      child.display(indent + '  ');
    }
  }

  getSize() {
    return this.children.reduce((total, child) => total + child.getSize(), 0);
  }
}

// use
const docs = new Directory('docs');
docs.add(new FileLeaf('readme.txt', 1200));
docs.add(new FileLeaf('license.txt', 800));

const root = new Directory('project');
root.add(docs);
root.add(new FileLeaf('app.jar', 50_000));

root.display('');
console.log('Total size:', root.getSize());

The caller never asks “are you a file or a directory?” It just calls display and getSize.

A shop bundle example

The same shape works for products.

class PricedComponent:
    def price(self) -> float:
        raise NotImplementedError


class Item(PricedComponent):
    def __init__(self, name: str, amount: float) -> None:
        self._name = name
        self._amount = amount

    def price(self) -> float:
        return self._amount


class Bundle(PricedComponent):
    def __init__(self) -> None:
        self._children: list[PricedComponent] = []

    def add(self, child: PricedComponent) -> None:
        self._children.append(child)

    def price(self) -> float:
        return sum(child.price() for child in self._children)


# use
starter = Bundle()
starter.add(Item("tea", 6))
starter.add(Item("honey", 4))

cart = Bundle()
cart.add(Item("mug", 8))
cart.add(starter)

print(f"total={cart.price()}")  # 18.0

public interface PricedComponent {
    double price();
}

public class Item implements PricedComponent {
    private final String name;
    private final double amount;

    public Item(String name, double amount) {
        this.name = name;
        this.amount = amount;
    }

    @Override
    public double price() {
        return amount;
    }
}

public class Bundle implements PricedComponent {
    private final List<PricedComponent> children = new ArrayList<>();

    public void add(PricedComponent child) {
        children.add(child);
    }

    @Override
    public double price() {
        return children.stream().mapToDouble(PricedComponent::price).sum();
    }
}

// use
Bundle starter = new Bundle();
starter.add(new Item("tea", 6));
starter.add(new Item("honey", 4));

Bundle cart = new Bundle();
cart.add(new Item("mug", 8));
cart.add(starter);

System.out.println("total=" + cart.price()); // 18.0

type PricedComponent interface {
	Price() float64
}

type Item struct {
	Name   string
	Amount float64
}

func (i Item) Price() float64 { return i.Amount }

type Bundle struct {
	children []PricedComponent
}

func (b *Bundle) Add(child PricedComponent) {
	b.children = append(b.children, child)
}

func (b *Bundle) Price() float64 {
	total := 0.0
	for _, child := range b.children {
		total += child.Price()
	}
	return total
}

// use
starter := &Bundle{}
starter.Add(Item{Name: "tea", Amount: 6})
starter.Add(Item{Name: "honey", Amount: 4})

cart := &Bundle{}
cart.Add(Item{Name: "mug", Amount: 8})
cart.Add(starter)

fmt.Println("total=", cart.Price()) // 18

interface PricedComponent {
  price(): number;
}

class Item implements PricedComponent {
  constructor(
    private name: string,
    private amount: number,
  ) {}

  price() {
    return this.amount;
  }
}

class Bundle implements PricedComponent {
  private children: PricedComponent[] = [];

  add(child: PricedComponent) {
    this.children.push(child);
  }

  price() {
    return this.children.reduce((total, child) => total + child.price(), 0);
  }
}

// use
const starter = new Bundle();
starter.add(new Item('tea', 6));
starter.add(new Item('honey', 4));

const cart = new Bundle();
cart.add(new Item('mug', 8));
cart.add(starter);

console.log('total=', cart.price()); // 18

Bundles can nest inside bundles. The total still works, no matter how deep.

When it helps

Use Composite when your domain is naturally a tree and the same operations make sense on both leaves and groups: size, price, draw, validate, export.

It shines when client code would otherwise fill up with “if leaf / if group” branches for every new feature.

When it hurts

If the structure is flat — just a list of independent items — Composite adds ceremony without benefit.

Be careful with operations that only make sense for groups, like add(child). If you put add on the shared interface, leaves must either throw or no-op, which can surprise callers. Many designs keep child management on the composite type only. Also watch performance on huge trees: a naive recursive size walk touches everything every time.

Practical tips

Define a small component interface with operations meaningful for both leaves and groups.
Keep leaf classes simple; put child lists only on composites.
Prefer recursion that is easy to read over clever micro-optimizations, until profiling says otherwise.
Document whether the order of children matters.
Do not force Composite onto problems that are really just plain collections.

Check your understanding

What is Composite, in one sentence?
A design that lets individual objects and groups of objects share one interface in a tree.

What is a leaf?
A node with no children.

What is a composite?
A node that contains children and usually forwards operations to them.

Why do callers like it?
They can ignore the difference between one item and a nested group.

What to learn next

Next: Strategy Pattern — the focus shifts from how objects are arranged to how behavior is chosen and swapped.