Liskov Substitution Principle in LLD - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Liskov Substitution Principle (LSP)?

LSP means that objects of a parent class should be replaceable with objects of a child class without changing the correctness of the program.

beginner

Why is LSP important in system design?

It ensures that components can be replaced or extended without breaking the system, making designs more flexible and maintainable.

beginner

Give a simple real-life example of LSP.

If a car can be replaced by an electric car without changing how you drive it, then the electric car follows LSP with car.

intermediate

What can happen if LSP is violated?

Replacing a parent object with a child object may cause errors or unexpected behavior, breaking the system.

intermediate

How does LSP relate to method overriding?

Overridden methods in child classes must behave consistently with the parent methods to follow LSP.

What does the Liskov Substitution Principle ensure?

A Child classes can replace parent classes without errors

B Parent classes cannot be extended

C Child classes must have fewer methods

D Parent classes must be abstract

LSP ensures child classes can replace parent classes without breaking the program.

Which of these violates LSP?

A Child class adds new methods

B Child class changes method behavior breaking parent expectations

C Child class inherits all parent methods unchanged

D Parent class is abstract

Changing method behavior that breaks parent expectations violates LSP.

LSP is a principle related to which programming concept?

A Network protocols

B Database normalization

C Inheritance and polymorphism

D UI design

LSP deals with inheritance and polymorphism in object-oriented programming.

If a subclass method throws unexpected exceptions not declared in the parent, does it follow LSP?

A No, it violates LSP

B Yes, it follows LSP

C Only if exceptions are caught

D Exceptions do not affect LSP

Throwing unexpected exceptions breaks the contract and violates LSP.

Which is a benefit of following LSP in system design?

A Less reusable code

B More complex code

C Slower performance

D Easier to extend and maintain code

Following LSP makes code easier to extend and maintain.

Explain the Liskov Substitution Principle with a simple example.

Think about replacing a parent object with a child object without breaking the system.

Describe what can go wrong if the Liskov Substitution Principle is not followed in a system.

Consider what happens when a child class does not behave like its parent.

Practice

1.

What does the Liskov Substitution Principle (LSP) primarily ensure in system design?

easy

A. Child classes can replace parent classes without affecting correctness

B. Parent classes must never be extended

C. Child classes should have fewer methods than parent classes

D. Parent classes should depend on child classes

Solution

1. Step 1: Understand LSP definition

   LSP states that objects of a child class should be replaceable with objects of the parent class without breaking the program.

2. Step 2: Analyze options against LSP

   Only Child classes can replace parent classes without affecting correctness correctly describes this principle. Other options contradict LSP or are unrelated.

3. Final Answer:

   Child classes can replace parent classes without affecting correctness -> Option A

4. Quick Check:

   Liskov Substitution Principle = Child replaces Parent [OK]

Hint: LSP means child works anywhere parent is expected [OK]

Common Mistakes:

• Thinking LSP forbids inheritance
• Confusing LSP with interface segregation
• Believing child classes can change parent behavior arbitrarily

2.

Which of the following class declarations follows the Liskov Substitution Principle?

class Bird {
  fly() {}
}

class Penguin extends Bird {
  fly() {
    throw new Error('Cannot fly');
  }
}

easy

A. Yes, because Penguin is a Bird

B. No, because Penguin breaks expected behavior of Bird

C. Yes, because Penguin overrides fly method

D. No, because Bird should not have fly method

Solution

1. Step 1: Analyze Penguin's fly method

   Penguin throws an error on fly(), but Bird expects fly() to work normally.

2. Step 2: Check LSP compliance

   Since Penguin cannot be used where Bird is expected (fly method fails), it violates LSP.

3. Final Answer:

   No, because Penguin breaks expected behavior of Bird -> Option B

4. Quick Check:

   Child must not break parent behavior = No [OK]

Hint: Child must not break parent's expected methods [OK]

Common Mistakes:

• Ignoring method behavior changes in child
• Assuming inheritance alone guarantees LSP
• Thinking overriding with error is allowed

3.

Consider the following code snippet. What will be the output?

class Vehicle {
  start() { return 'Vehicle started'; }
}

class Car extends Vehicle {
  start() { return 'Car started'; }
}

function startVehicle(v) {
  return v.start();
}

const myCar = new Car();
console.log(startVehicle(myCar));

medium

A. 'Vehicle started'

B. Error: start is not a function

C. 'Car started'

D. undefined

Solution

1. Step 1: Understand method overriding

   Car overrides start() method to return 'Car started'.

2. Step 2: Trace function call

   startVehicle(myCar) calls myCar.start(), which returns 'Car started'.

3. Final Answer:

   'Car started' -> Option C

4. Quick Check:

   Overridden method returns child's message [OK]

Hint: Child method overrides parent, so child's output shows [OK]

Common Mistakes:

• Expecting parent method output instead of child's
• Confusing method names or forgetting override
• Assuming error due to polymorphism

4.

Identify the violation of Liskov Substitution Principle in the code below and select the fix.

class Rectangle {
  setWidth(w) { this.width = w; }
  setHeight(h) { this.height = h; }
  area() { return this.width * this.height; }
}

class Square extends Rectangle {
  setWidth(w) {
    this.width = w;
    this.height = w;
  }
  setHeight(h) {
    this.width = h;
    this.height = h;
  }
}

medium

A. Use separate classes without inheritance for Square and Rectangle

B. Square should not override setWidth and setHeight

C. Square should only override area() method

D. No violation, code is correct

Solution

1. Step 1: Identify LSP violation

   Square changes behavior of setWidth and setHeight, breaking Rectangle's expectations.

2. Step 2: Choose fix

   To follow LSP, Square and Rectangle should not be in inheritance relation if behaviors differ fundamentally.

3. Final Answer:

   Use separate classes without inheritance for Square and Rectangle -> Option A

4. Quick Check:

   Different behavior means no inheritance [OK]

Hint: If child changes parent's method meaning, avoid inheritance [OK]

Common Mistakes:

• Ignoring behavioral changes in overridden methods
• Trying to fix by only overriding area()
• Assuming inheritance always fits shapes

5.

You are designing a payment system with a base class PaymentMethod and subclasses CreditCard and Bitcoin. The base class has a method processPayment(amount) that returns a success message. However, Bitcoin payments require additional confirmation steps and may fail differently. How should you design these classes to follow the Liskov Substitution Principle?

hard

A. Make processPayment abstract and force subclasses to implement their own versions ignoring base behavior

B. Make Bitcoin inherit PaymentMethod and override processPayment to throw errors on failure

C. Remove inheritance and implement separate interfaces for each payment type

D. Keep Bitcoin and CreditCard as subclasses but ensure processPayment behaves consistently and returns success/failure uniformly

Solution

1. Step 1: Understand LSP in payment context

   Subclasses must behave so they can replace base class without breaking client code.

2. Step 2: Design consistent behavior

   Bitcoin and CreditCard should implement processPayment so it returns success/failure in a consistent way, hiding internal differences.

3. Final Answer:

   Keep Bitcoin and CreditCard as subclasses but ensure processPayment behaves consistently and returns success/failure uniformly -> Option D

4. Quick Check:

   Consistent behavior across subclasses = LSP compliance [OK]

Hint: Subclasses must behave consistently to replace parent safely [OK]

Common Mistakes:

• Throwing errors breaking expected method contracts
• Ignoring different failure modes without abstraction
• Removing inheritance unnecessarily