Composition vs Inheritance in Java

// BAD: Inheritance misused — Queue is NOT a Stack (IS-A fails)
class BadQueue extends java.util.Stack<Integer> {
    void enqueue(int x) { push(x); }   // borrows Stack.push
    int  dequeue()      { return remove(0); }
    // Problem: callers can also call inherited pop(), peek(), search() —
    // all of which break queue semantics. The IS-A test failed.
}

// GOOD: Composition — Queue HAS-A Deque, delegates only what's needed
class Queue {
    private final Deque<Integer> data = new ArrayDeque<>();  // HAS-A

    void enqueue(int x) { data.addLast(x); }    // delegate
    int  dequeue()      { return data.removeFirst(); }      // delegate
    int  size()         { return data.size(); }
    // The backing store is private — callers see only queue operations.
    // Swap ArrayDeque for another Deque implementation anytime.
}

// BONUS: Composition enables runtime behaviour swapping (Strategy pattern)
interface SortStrategy {
    void sort(int[] arr);
}

class Sorter {
    private SortStrategy strategy;           // HAS-A (injected)
    Sorter(SortStrategy s) { this.strategy = s; }
    void sort(int[] arr)   { strategy.sort(arr); }
    void setStrategy(SortStrategy s) { this.strategy = s; } // swap at runtime!
}