Liskov substitution

A BankAccount base class has a withdraw(amount) method. A SavingsAccount subclass overrides it to throw when the balance would drop below a $100 minimum. Code that accepts a BankAccount and calls withdraw suddenly crashes with an unexpected exception — even though the runtime type is technically a bank account.

The problem

1 class Account {
2   #balance;
3   constructor(balance) { this.#balance = balance; }
4   get balance() { return this.#balance; }
5   withdraw(amount) {
6     if (amount > this.#balance) throw new Error("Insufficient funds");
7     this.#balance -= amount;
8   }
9 }
10 class SavingsAccount extends Account {
11   withdraw(amount) {
12     // Adds a new precondition: balance must stay above 100.
13     if (this.balance - amount < 100) throw new Error("Below minimum");
14     super.withdraw(amount);
15   }
16 }
17 function processWithdrawal(account, amount) {
18   account.withdraw(amount); // Crashes if account is a SavingsAccount and balance - amount < 100.
19 }

processWithdrawal accepts an Account, so every caller assumes they can safely withdraw if amount <= balance. SavingsAccount silently breaks that assumption by adding a new precondition.

The rule

Liskov substitution principle: if S is a subtype of T, then every object of type T in a program may be replaced by an object of type S without altering any of the correct properties of that program.

The two most common violations:

1. Strengthened preconditions — the subclass requires more than the parent (new guards, restricted inputs).
2. Weakened postconditions — the subclass produces less than the parent (throwing instead of returning, returning a narrower set of values).

In code

Make the minimum-balance rule explicit in SavingsAccount.canWithdraw instead of strengthening the inherited postcondition:

Spotting violations early

LSP violations usually appear as instanceof checks inside callers:

1 if (account instanceof SavingsAccount) { /* handle minimum */ }
2 account.withdraw(amount);

Every instanceof guard in a polymorphic call site is a symptom. Move the variation into the subclass, or use composition instead of inheritance.

Where you have already seen it

Java's ArrayList and LinkedList both implement List. Code that accepts a List works with either. Java's Stack extends Vector and does not satisfy LSP — Vector.add() inserts at any position, but a stack should only push to the top, making Stack a famous example of inheritance misuse in the standard library.