This rule of design pattern assure that if
a class derived from base class then base class should be a proper substitute
for derived class.
“The derived classes should
be perfectly substitutable for their base classes”.
In the below example “Jeep” Class object is
representing “Trucker” Object. AS per LSP principle it should be wrong.
/// <summary>
/// Jeep Class
/// </summary>
public class
Jeep
{
public virtual int Speed()
{
return
60;
}
}
/// <summary>
/// Truck
Class inherit
/// </summary>
public class
Trucker : Jeep
{
public override int Speed()
{
return
55;
}
}
Jeep jep = new Trucker();
Console.WriteLine(jep.Speed().ToString());
Implementation of “Liskov substitution
Principle”
We must make sure that the new derived classes just extend
without replacing the functionality of old classes. Otherwise the new classes
can produce undesired effects when they are used in existing program modules.
/// <summary>
///
Abstract class for vechile
/// </summary>
public abstract
class Vechile
{
public abstract int Speed();
}
/// <summary>
/// Jeep Class
/// </summary>
public class
Jeep : Vechile
{
public override int Speed()
{
return
60;
}
}
/// <summary>
/// Truck
Class inherit
/// </summary>
public class
Trucker : Jeep
{
public override int Speed()
{
return 55;
}
}
I have implement new abstract class for
Vehicle & it is derived for all classes. Ie “Jeep” derived from “Vehicle” and
“trucker” derived from “Jeep”. But we can represent Both “Jeep” & “Trucker”
object using “Vechile” object.
Vechile vehicle = new Jeep();
Console.WriteLine(vehicle.Speed().ToString());
vehicle = new
Trucker();
Console.WriteLine(vehicle.Speed().ToString());
No comments:
Post a Comment