What is the difference between composition and inheritance in Java?

// Superclass
public class Animal {
    protected String name;

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

    public String speak() {
        return name + " makes a sound";
    }
}

// Subclass — IS-A relationship
public class Dog extends Animal {

    public Dog(String name) {
        super(name);
    }

    @Override
    public String speak() {
        return name + " barks";   // overrides parent behaviour
    }
}

// Usage
Animal animal = new Dog("Rex");
System.out.println(animal.speak());  // Rex barks  (polymorphism)

// A classic example: InstrumentedHashSet
// Goal: count every element ever added

public class InstrumentedHashSet<E> extends HashSet<E> {
    private int addCount = 0;

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);   // ← BUG: HashSet.addAll calls add() internally
    }

    public int getAddCount() { return addCount; }
}

// After addAll(List.of("a","b","c"))
// addCount becomes 6 instead of 3 — addAll calls add(), doubling the count

// Fixed InstrumentedSet using composition
public class InstrumentedSet<E> implements Set<E> {
    private final Set<E> set;   // composed object (HAS-A)
    private int addCount = 0;

    public InstrumentedSet(Set<E> set) {
        this.set = set;
    }

    @Override
    public boolean add(E e) {
        addCount++;
        return set.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return set.addAll(c);   // delegates — no internal double-counting
    }

    public int getAddCount() { return addCount; }

    // delegate remaining Set methods to set...
    @Override public int size()               { return set.size(); }
    @Override public boolean isEmpty()        { return set.isEmpty(); }
    @Override public boolean contains(Object o){ return set.contains(o); }
    @Override public Iterator<E> iterator()  { return set.iterator(); }
    @Override public Object[] toArray()       { return set.toArray(); }
    @Override public <T> T[] toArray(T[] a)  { return set.toArray(a); }
    @Override public boolean remove(Object o) { return set.remove(o); }
    @Override public boolean containsAll(Collection<?> c){ return set.containsAll(c); }
    @Override public boolean removeAll(Collection<?> c)  { return set.removeAll(c); }
    @Override public boolean retainAll(Collection<?> c)  { return set.retainAll(c); }
    @Override public void clear()             { set.clear(); }
}

// Printer capability — modelled as a separate class
public class Printer {
    public void print(String document) {
        System.out.println("Printing: " + document);
    }
}

// OfficeWorker HAS-A Printer — uses delegation
public class OfficeWorker {
    private final Printer printer;   // composed dependency

    public OfficeWorker(Printer printer) {
        this.printer = printer;      // injected — easy to swap/mock
    }

    public void submitReport(String report) {
        System.out.println("Finalising report...");
        printer.print(report);       // delegates printing responsibility
    }
}

// Usage
Printer p = new Printer();
OfficeWorker worker = new OfficeWorker(p);
worker.submitReport("Q2 Sales Numbers");

// Inheritance: LoggingStack extends Stack
public class Stack<T> {
    protected final java.util.LinkedList<T> list = new java.util.LinkedList<>();

    public void push(T item)  { list.addFirst(item); }
    public T    pop()         { return list.removeFirst(); }
    public T    peek()        { return list.getFirst(); }
    public int  size()        { return list.size(); }
}

public class LoggingStack<T> extends Stack<T> {  // IS-A Stack

    @Override
    public void push(T item) {
        System.out.println("PUSH: " + item);
        super.push(item);
    }

    @Override
    public T pop() {
        T item = super.pop();
        System.out.println("POP: " + item);
        return item;
    }
}
// Problem: LoggingStack inherits direct access to `list` — tight coupling

// Composition: LoggingStack HAS-A Stack
public class LoggingStack<T> {
    private final Stack<T> stack;   // composed — not inherited

    public LoggingStack(Stack<T> stack) {
        this.stack = stack;
    }

    public void push(T item) {
        System.out.println("PUSH: " + item);
        stack.push(item);
    }

    public T pop() {
        T item = stack.pop();
        System.out.println("POP: " + item);
        return item;
    }

    public int size() { return stack.size(); }
}

// Usage — can wrap any Stack implementation at runtime
LoggingStack<Integer> ls = new LoggingStack<>(new Stack<>());
ls.push(42);
ls.pop();