Then (y)should be true for objects y of type. (x) be a property provable about objects x of type T. Liskov Substitution Principal as defined by Barbara Liskov & Jeannette Wing. Would expect only its area value without making any assumptions regardless its behavior related to its properties mutation. This article explains Liskov Substitution Principle with examples in Java, the Circle-Ellipse Problem and the relation of this principle with Open/Closed Principle. Now, Wherever the client method will use rectangle, it When we creating an immutable `Square` we enforce our invariants without an influence on the base class behavior. Public class Square extends Rectangle void setWidth(int width) void setHeight(int height) Īll properly constructed `Square`s will be valid `Rectangle`s. So, since `square` is a `rectangle` _(mathematically)_ we can implement `square` as a descendant of `rectangle`: # Classic LSP example _(Rectangle & Square)_

If `doSomething(SomeClass duck)` method works with instances of `SomeClass`, it does so with instances of any subclass of `SomeClass`. * decreases a possibility of creation of hierarchies that do not conform Open-Closed Principle _(OCP)_. * the way to characterize good inheritance hierarchies **Barbara Liskov Substitution Principle benefits:** Otherwords, Subclass should override the parent class’ methods in a way that does not break functionality from a client’s point of view. It means that we must ensure that new derived classes extend the base classes without changing ancestor's behavior.Ĭhild classes should never break the parent class’ type definitions - simplified interpretation Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program. That is, if S is a subtype of T, then objects of type T in a program P may be replaced with objects of type S without altering any of the desirable properties (correctness) of that program P. Subtypes must be behaviorally substitutable for their base types - official formulation

Liskov substitution principle java