Liskov Substitution Principle

The Liskov Substitution Principle states that:

Child classes should never break the parent class' type definitions.

According to this principle, a subclass should override the parent class's methods in a way that does not break functionality from a client's point of view.

According to this principle, if a class is extending another class, the functionality of the child class should not conflict with that of its parent.

We can demonstrate this with the following example:

public class Rectangle { 
   private double length; 
   private double height; 
 
 
   public void setLength(double length) { 
       this.length = length; 
   } 
 
   public void setHeight(double height) { 
       this.height = height; 
   } 
 
   public double getLength() { 
       return length; 
   } 
 
   @Override 
   public double getHeight() { 
       return height; 
   } 
 
   public double getArea() { 
       return (length * height); 
   } 
} 

Here we have a rectangle. As we know, a square is also a type of rectangle, so it can extend the Rectangle class. Also we know that the height and the width of the square have to be the same so the getter can be written like this:

public class Square extends Rectangle { 
 
   @Override 
   public void setHeight(double height) { 
       this.length = height; 
       this.height = height; 
   } 
 
   @Override 
   public void setLength(double length) { 
       this.length = length; 
       this.height = length; 
   } 
} 

As can be seen from the preceding definition, we can get a rectangle also from the square implementation.

So now let's get an instance of Rectangle from the Square class:

Rectangle r = new Square(); 
r.setHeight(5); 
r.setLength(10); 

Now if we try to get the area, we will get 100 instead of 50, as a square has both the same length and height, which is not the case with a rectangle, and this violates the Liskov Substitution Principle.

A simple example of the Liskov Substitution Principle would be a List and ArrayList. An ArrayList implements a List but it does not change the basic functionality of the List.