The Liskov Substitution Principle (LSP) is a fundamental concept in object-oriented programming that ensures the correctness and robustness of inheritance hierarchies. Formulated by Barbara Liskov, the principle states that objects of a superclass should be substitutable with objects of its subclasses without affecting the correctness of the program. In other words, if a class S is a subtype of class T, then objects of type T should be replaceable with objects of type S without altering the desirable properties of the program.
To illustrate this principle, consider a classic example of a Rectangle class and its subclass, Square. A Rectangle has both width and height properties, while a Square is a special case of a Rectangle where the width and height are equal. According to the LSP, any code that works with Rectangle objects should also work correctly with Square objects, as a Square is a subtype of Rectangle.
However, if the Rectangle class has a method setWidth(int width) and setHeight(int height), and the Square class overrides these methods to ensure that the width and height remain equal, it violates the LSP. This is because a Square object cannot be freely substituted for a Rectangle object, as it would break the expected behavior of the setWidth() and setHeight() methods.
To adhere to the LSP, the inheritance hierarchy should be designed in a way that subclasses do not alter the behavior of the superclass methods. In this case, it would be better to have a separate Shape interface or abstract class that defines common behaviors, and then have Rectangle and Square as separate implementations of that interface or subclasses of the abstract class.
By following the Liskov Substitution Principle, developers can create robust and maintainable inheritance hierarchies, ensuring that objects of derived classes can be used interchangeably with objects of their base classes without introducing unexpected behavior or breaking the correctness of the program.