Software Development

SOLID – Liskov Substitution Principle

Liskov Substitution principle (LSP) states that,

Methods that use references to the base classes must be able to use the objects of the derived classes without knowing it

This principle was written by Barbara Liskov in 1988.

The idea here is that the subtypes must be replaceable for the super type references without affecting the program execution.

This principle is very closely related to Open Closed Principle (OCP), violation of LSP in turn violates the OCP. Let me explain:

If the subtype is not replaceable for the supertype reference, then in order to support the subtype instances as well we go ahead and make changes to the existing code and add the support. This is a clear violation of OCP.

This is mostly seen in places where we do run time type identification and then cast it to appropriate reference type. And if we add a new subtype implementation then we would have to edit the code to test for instance of for the new subtype.

Let me give a subtle example:

class Bird {
  public void fly(){}
  public void eat(){}
class Crow extends Bird {}
class Ostrich extends Bird{
    throw new UnsupportedOperationException();
public BirdTest{
  public static void main(String[] args){
    List<Bird> birdList = new ArrayList<Bird>();
    birdList.add(new Bird());
    birdList.add(new Crow());
    birdList.add(new Ostrich());
    letTheBirdsFly ( birdList );
  static void letTheBirdsFly ( List<Bird> birdList ){
    for ( Bird b : birdList ) {;

What do you think would happen when this code is executed? As soon as an Ostrich instance is passed, it blows up!!! Here the sub type is not replaceable for the super type.

How do we fix such issues?

By using factoring. Sometimes factoring out the common features into a separate class can help in creating a hierarchy that confirms to LSP.

In the above scenario we can factor out the fly feature into- Flight and NonFlight birds.

class Bird{
  public void eat(){}
class FlightBird extends Bird{
  public void fly()()
class NonFlight extends Bird{}

So instead of dealing with Bird, we can deal with 2 categories of birds- Flight and NonFlight.

How can we identify LSP violation?

Derived class may require less functionalities than the Base class, so some methods would be redundant.
We might be using IS-A to check for Super-Sub relationships, but LSP doesn’t use only IS-A, but it also requires that the Sub types must be substitutable for the Super class. And one cannot decide the substitutability of sub class in isolation. One has to consider how the clients of the class hierarchy are going to use it.

A detailed paper by Robert Martin on LSP.

Reference: SOLID- Liskov Substitution Principle from our JCG partner Mohamed Sanaulla at the “Experiences Unlimited” blog.

Related Articles :
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Newest Most Voted
Inline Feedbacks
View all comments
7 years ago

It blows up because u created that exception to be thrown when fly method is invoked with an ostrich instance
Not a good example I have to say
Polymorphically speaking yr first example is correct

Andreas Schul
Andreas Schul
7 years ago

Your solution to solve LSP violation is flawed. The Fly behavior varies in the inheritance hierarchy, is should be abstracted away as an Interface and later used as composition in the Bird class and initialized in the run-time by the inheriting classes

Andreas Schul
Andreas Schul
7 years ago

My Solution: import java.util.*; interface FlyBehaviour { void fly(); } class CanFly implements FlyBehaviour { public void fly() { System.out.println(“Can fly”); } } class CannotFly implements FlyBehaviour { public void fly() { System.out.println(“Cannot fly”); } } class Bird { private FlyBehaviour flyBehaviour; public Bird(FlyBehaviour flyBehaviour) { this.flyBehaviour = flyBehaviour; } public void eat(){ } public void fly() {; } } class Crow extends Bird { public Crow(FlyBehaviour flyBehaviour) { super(flyBehaviour); } } class Ostrich extends Bird{ public Ostrich(FlyBehaviour flyBehaviour) { super(flyBehaviour); } } public class LSP { static void letTheBirdsFly ( List birdList ){ for ( Bird b :… Read more »

Back to top button