Liskov Substitution Principle in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to ensure the subclass can replace the superclass without errors.

LLD

class Bird:
    def fly(self):
        print("Flying")

class [1](Bird):
    def fly(self):
        print("Flying high")

Drag options to blanks, or click blank then click option'

AEagle

BPenguin

COstrich

DFish

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing a subclass that cannot perform the superclass's behavior (like Penguin).

Using a non-bird class as subclass.

The subclass Eagle correctly extends Bird and overrides fly without breaking behavior, following Liskov Substitution Principle.

2fill in blank

medium

Complete the method to follow Liskov Substitution Principle by not throwing unexpected exceptions.

LLD

class Rectangle:
    def set_width(self, width):
        self.width = width

class Square(Rectangle):
    def set_width(self, width):
        if width < 0:
            raise ValueError("Width must be positive")
        self.width = width

    def set_height(self, height):
        if [1]:
            raise ValueError("Height must be positive")
        self.width = height

Drag options to blanks, or click blank then click option'

Aheight > 0

Bheight == 0

Cheight < 0

Dheight != 0

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for positive values instead of invalid negative values.

Not validating input leading to inconsistent behavior.

The check height < 0 ensures the method does not accept invalid values, maintaining consistent behavior with the superclass.

3fill in blank

hard

Fix the error in the subclass method to respect Liskov Substitution Principle by matching the superclass method signature.

LLD

class Vehicle:
    def start(self, key):
        print("Vehicle started")

class Car(Vehicle):
    def start(self, [1]):
        print("Car started")

Drag options to blanks, or click blank then click option'

Akey

Bengine

Cignition

Dstart_key

Attempts:

3 left

💡 Hint

Common Mistakes

Renaming parameters in subclass methods.

Adding or removing parameters in subclass methods.

The subclass method must use the same parameter name key to maintain substitutability and avoid breaking client code.

4fill in blank

hard

Fill both blanks to ensure the subclass method signature and behavior follow Liskov Substitution Principle.

LLD

class PaymentProcessor:
    def process_payment(self, amount):
        pass

class CreditCardProcessor(PaymentProcessor):
    def [1](self, [2]):
        print(f"Processing credit card payment of {amount}")

Drag options to blanks, or click blank then click option'

Aprocess_payment

Bamount

Cpay

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using different method names in subclass.

Changing parameter names or count.

The subclass method must have the same name process_payment and parameter amount to maintain substitutability.

5fill in blank

hard

Fill all three blanks to correctly implement a subclass that respects Liskov Substitution Principle by maintaining method signature and behavior.

LLD

class Logger:
    def log(self, message):
        print(message)

class FileLogger(Logger):
    def [1](self, [2]):
        with open('log.txt', 'a') as f:
            f.write([3] + '\n')

Drag options to blanks, or click blank then click option'

Alog

Bmessage

Dmsg

Attempts:

3 left

💡 Hint

Common Mistakes

Changing method or parameter names.

Not using the parameter in the method body.

The subclass method log uses the same parameter message and writes it to a file, preserving the expected behavior and signature.

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