Principio sustitución de Liskov

La Sustitución de Liskov es un principio fundamental del diseño orientado a objetos que fue propuesto por la matemática y científica de la computación, Barbara Liskov, en 1987. Este principio establece que, en un programa orientado a objetos, las instancias de una clase hija deben poder ser utilizadas en lugar de las instancias de la clase padre sin causar errores o comportamientos inesperados.

Ventajas

• Permite una mayor flexibilidad en el diseño de clases y objetos, lo que facilita la reutilización del código.
• Ayuda a reducir el acoplamiento entre clases, lo que hace que el código sea más modular y fácil de mantener.
• Mejora la interoperabilidad entre diferentes componentes de software, lo que puede ser útil en proyectos de gran envergadura y complejidad.
• Fomenta el uso de la herencia y la polimorfismo, lo que puede mejorar la claridad y la simplicidad del código.
• Permite una mayor escalabilidad del software al hacer que las clases sean más fáciles de extender y modificar.

Desventajas

• Puede llevar a un mayor complejidad en el diseño de clases y objetos, lo que puede dificultar la comprensión y el mantenimiento del código.
• Puede ser difícil de implementar correctamente, especialmente en proyectos grandes y complejos.
• Requiere un conocimiento profundo de la herencia y el polimorfismo, lo que puede ser un obstáculo para los desarrolladores principiantes.
• Puede ser difícil de depurar en caso de errores, ya que los problemas pueden originarse en cualquier lugar donde se utilice la sustitución de Liskov.
• Puede afectar el rendimiento del software si se utiliza incorrectamente o si se abusa de ella en el diseño de clases y objetos.

Ejemplo en C#

Supongamos que tenemos una clase base llamada Vehiculo que representa un vehículo genérico y dos clases hijas llamadas Automovil y Motocicleta que heredan de la clase base. Ambas clases hijas tienen una propiedad llamada NumeroDeRuedas, que devuelve el número de ruedas del vehículo.

public class Vehiculo
{
    public virtual string Conducir()
    {
        return "Conduciendo un vehículo genérico";
    }
}

public class Automovil : Vehiculo
{
    public override string Conducir()
    {
        return "Conduciendo un automóvil";
    }

    public int NumeroDeRuedas
    {
        get { return 4; }
    }
}

public class Motocicleta : Vehiculo
{
    public override string Conducir()
    {
        return "Conduciendo una motocicleta";
    }

    public int NumeroDeRuedas
    {
        get { return 2; }
    }
}

Ahora, supongamos que tenemos un método que acepta una instancia de la clase Vehiculo y devuelve el número de ruedas del vehículo. Este método utiliza la propiedad NumeroDeRuedas de la clase Automovil y Motocicleta para obtener el número de ruedas.

public int ObtenerNumeroDeRuedas(Vehiculo vehiculo)
{
    if (vehiculo is Automovil)
    {
        return ((Automovil)vehiculo).NumeroDeRuedas;
    }
    else if (vehiculo is Motocicleta)
    {
        return ((Motocicleta)vehiculo).NumeroDeRuedas;
    }
    else
    {
        throw new ArgumentException("El objeto pasado como parámetro no es un vehículo válido.");
    }
}

Este método funciona correctamente, pero tiene un problema: si agregamos una nueva clase hija de Vehiculo en el futuro, como Bicicleta, deberíamos modificar el método ObtenerNumeroDeRuedas para incluir esta nueva clase. Esto viola el principio de la Sustitución de Liskov, ya que no podemos utilizar una instancia de Bicicleta en lugar de una instancia de Vehiculo sin modificar el método.

Para solucionar este problema, podemos utilizar la Sustitución de Liskov y crear una propiedad virtual NumeroDeRuedas en la clase base Vehiculo. Luego, podemos hacer que las clases hijas Automovil, Motocicleta y Bicicleta anulen esta propiedad para devolver el número de ruedas correspondiente.

public class Vehiculo
{
    public virtual string Conducir()
    {
        return "Conduciendo un vehículo genérico";
    }

    public virtual int NumeroDeRuedas
    {
        get { return 0; }
    }
}

public class Automovil : Vehiculo
{
    public override string Conducir()
    {
        return "Conduciendo un automóvil";
    }

    public override int NumeroDeRuedas
    {
        get { return 4; }
    }
}

public class Motocicleta : Vehiculo
{
    public override string Conducir()
    {
        return "Conduciendo una motocicleta";
    }

    public override int NumeroDeRuedas
    {
        get { return 2; }
    }
}

public class Bicicleta : Vehiculo
{
    public override string Conducir()
    {
        return "Conduciendo una bicicleta";
    }

    public override int NumeroDeRuedas
    {
        get { return 2; }
    }
}

Ahora, podemos modificar el método ObtenerNumeroDeRuedas para utilizar la propiedad NumeroDeRuedas de la clase base Vehiculo en lugar de las propiedades específicas de cada clase hija.

public int ObtenerNumeroDeRuedas(Vehiculo vehiculo)
{
    return vehiculo.NumeroDeRuedas;
}

Con este cambio, podemos utilizar una instancia de cualquier clase hija de Vehiculo en lugar de una instancia de Vehiculo sin tener que modificar el método ObtenerNumeroDeRuedas, lo que cumple con el principio de la Sustitución de Liskov.

Volver a: Principios SOLID