Understanding the SOLID Principles: The Liskov Substitution Principle(LSP)

3 min read6 days ago

When it comes to writing clean, maintainable, and scalable code, the SOLID principles of Object-Oriented Programming (OOP) are your best friends. Today, we’re going to dive into the Liskov Substitution Principle (LSP), the “L” in SOLID. Don’t worry if you’re new to programming or OOP — by the end of this article, you’ll have a clear understanding of what LSP is, why it matters, and how to apply it in JavaScript.

What is the Liskov Substitution Principle?

The Liskov Substitution Principle (LSP) is named after Barbara Liskov, who introduced it in 1987. In simple terms, it states:

“Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.”

In other words, if you have a base class (superclass) and a derived class (subclass), you should be able to use an instance of the subclass wherever an instance of the superclass is expected, without breaking the program.

Why is LSP Important?

LSP ensures that your code is flexible and reliable. It helps you design class hierarchies that are easy to extend and maintain. If you violate LSP, you might end up with unexpected bugs, especially when adding new subclasses or modifying existing ones.

🔹 Real-World Analogy

Imagine you have a Bird class. All birds can fly, right? But what happens when we introduce a Penguin subclass?

A penguin is a bird 🐦
But a penguin cannot fly ❌

If we have a function that expects any Bird to fly, introducing a Penguin will break the program. This violates Liskov Substitution Principle.

Now, let’s look at how this problem can appear in JavaScript.

🔹 Violating Liskov Substitution Principle in JavaScript

Consider the following code:

class Bird {
  fly() {
    console.log("Flying high!");
  }
}

class Penguin extends Bird {
  fly() {
    throw new Error("Penguins can't fly!");
  }
}

function makeBirdFly(bird) {
  bird.fly();
}

const bird = new Bird();
const penguin = new Penguin();

makeBirdFly(bird); // Works fine
makeBirdFly(penguin); // Throws an error!

🚨 What’s Wrong Here?

Penguin extends Bird, but it overrides the fly method incorrectly.
The program expects all birds to be able to fly.
When a Penguin is used in place of a Bird, it breaks the program — this violates LSP.

🔹 Fixing the Liskov Substitution Principle

To fix this, we need to rethink our class structure. Instead of assuming all birds can fly, we should create a separate FlyingBird class.

✅ Correct Implementation:

class Bird {
  // Common bird properties
}

class FlyingBird extends Bird {
  fly() {
    console.log("I can fly!");
  }
}

class Sparrow extends FlyingBird {}

class Penguin extends Bird {
  swim() {
    console.log("I can swim!");
  }
}

// Function that works only for flying birds
function makeBirdFly(bird) {
  bird.fly();
}

// Works fine
makeBirdFly(new Sparrow()); // Output: "I can fly!"

// Now, Penguins are not considered FlyingBirds, so no errors occur.
const penguin = new Penguin();
penguin.swim(); // Output: "I can swim!"

🎯 What Did We Fix?

✔️ We removed the incorrect assumption that all birds can fly.
✔️ Flying behavior is now limited to FlyingBird instead of Bird.
✔️ Penguin no longer overrides an invalid method, following LSP correctly.

🔹 Key Takeaways

1️⃣ A subclass should always be replaceable for its superclass without breaking the code.
2️⃣ Design your class hierarchies carefully. If a subclass can’t fully support the behavior of its superclass, it might be a sign that your design needs improvement.
3️⃣ Use inheritance wisely. Not all real-world relationships fit neatly into an “is-a” hierarchy.

By following Liskov Substitution Principle, we ensure that our code is more predictable, reusable, and bug-free!

🔹 Final Thoughts

Understanding SOLID principles helps us become better developers. The Liskov Substitution Principle (LSP) is often ignored, but applying it correctly leads to cleaner and more maintainable code.

I hope this post helped you understand LSP better. If you have any questions, drop them in the comments! 🚀

💡 Did you enjoy this article? Give it a clap 👏 and share it with others!