Composition vs Inheritance

A new developer wants a Stack and notices that ArrayList already stores items, so they write class Stack extends ArrayList. Now anyone can call stack.add(0, x) and insert into the middle of the "stack", breaking its whole point. The classic advice, "favor composition over inheritance", comes from bugs exactly like this. This lesson shows when each is the right tool, and how to refactor from one to the other.

The Same Goal, Two Designs

import java.util.ArrayList;
import java.util.List;
 
public class Counter {
    static class TicketQueue {
        private final List<String> waiting = new ArrayList<>();
 
        void join(String name) { waiting.add(name); }
        String next() { return waiting.remove(0); }
        int size() { return waiting.size(); }
    }
 
    public static void main(String[] args) {
        TicketQueue queue = new TicketQueue();
        queue.join("Navika");
        queue.join("Srihitha");
        queue.join("Advitha");
        System.out.println("Serving " + queue.next());
        System.out.println("Still waiting: " + queue.size());
    }
}

import java.util.ArrayList;
 
public class CounterBad {
    static class TicketQueue extends ArrayList<String> {
        void join(String name) { add(name); }
        String next() { return remove(0); }
    }
 
    public static void main(String[] args) {
        TicketQueue queue = new TicketQueue();
        queue.join("Navika");
        queue.join("Srihitha");
        queue.add(0, "Advitha");     // jumps the queue: allowed!
        queue.clear();               // empties everyone: allowed!
        System.out.println("Waiting: " + queue.size());
    }
}

Serving Navika
Still waiting: 2

How it works

1. In the composition version, TicketQueue has a private list. Outside code can only join, take the next person, or ask the size; the queue's rules can't be broken.
2. In the inheritance version, TicketQueue is an ArrayList, so it inherits around 40 public methods. add(0, ...) lets someone jump the queue; clear() empties it. The class can't stop either.
3. A ticket queue isn't a kind of list; it uses a list. That's the signal to compose.

Try it yourself: add a method boolean isEmpty() to the composition version. Which list method does it call?

Why Inheritance Can Be Fragile

Composition avoids all four: the outer class decides what to expose, depends only on the inner object's public methods, and can swap the inner object at runtime.

A Checklist

Use inheritance only if all of these are true:

1. "Child is a Parent" makes sense to a non-programmer.
2. Every public method of the parent makes sense on the child.
3. The child can be used anywhere the parent is expected without surprises (the Liskov substitution principle, see "SOLID Principles in Java").
4. The parent was designed to be extended, or you control both classes.

If any answer is no, use composition.

Common Mistakes

Extending a collection or utility class for convenience. extends ArrayList, extends HashMap, extends Thread are classic mistakes; hold one instead.

Deep hierarchies to share small bits of code. A helper object shared by composition is simpler.

Forbidding inheritance completely. Real is-a hierarchies, such as account types or shapes, are a perfect fit for it.

Interview Corner

Practice

1. Easy: Decide inheritance or composition: Car and Engine; Circle and Shape; Logger and File; Manager and Employee.
2. Harder: Write a Stack class by composition with push, pop, peek and isEmpty, holding a private ArrayList<Integer>.

Key Takeaways