Liskov substitution

El principio de sustitución de Liskov (LSP) es otro de los cinco principios SOLID de la programación orientada a objetos. Establece que una clase derivada debe ser sustituible por su clase base sin que ello afecte al funcionamiento del programa.

En otras palabras, una clase derivada debe conservar el comportamiento de su clase base.

Este principio tiene varias ventajas, entre ellas:

• Mejora la mantenibilidad: Si una clase derivada es sustituible por su clase base, es más fácil realizar cambios en el código existente sin introducir errores.
• Mejora la reusabilidad: Las clases que cumplen el principio LSP son más fáciles de reutilizar en otros contextos.
• Mejora la flexibilidad: Las clases que cumplen el principio LSP son más fáciles de modificar para adaptarse a nuevos requisitos.

Ejemplo 1:

public abstract class Figura {
    public abstract double CalcularArea();
}

public class Cuadrado : Figura {
    private double lado;

    public Cuadrado(double lado) {
        this.lado = lado;
    }

    public override double CalcularArea() {
        return lado * lado;
    }
}

public class Circulo : Figura {
    private double radio;

    public Circulo(double radio) {
        this.radio = radio;
    }

    public override double CalcularArea() {
        return Math.PI * Math.pow(radio, 2);
    }
}

public class Main {
    public static void Main(string[] args) {
        List<Figura> figuras = new List<Figura>();
        figuras.Add(new Cuadrado(5));
        figuras.Add(new Circulo(10));

        foreach (Figura figura in figuras) {
            Console.WriteLine(figura.CalcularArea());
        }
    }
}

En este ejemplo, la clase Figura es abstracta, lo que significa que no se puede instanciar directamente. Sin embargo, se puede usar como base para crear otras clases, como Cuadrado y Circulo.

Las clases Cuadrado y Circulo cumplen el principio LSP, ya que se pueden sustituir por la clase Figura sin afectar al funcionamiento del programa.

Por ejemplo, en el método Main(), se crea una lista de figuras que contiene un cuadrado y un círculo. Luego, se itera por la lista y se llama al método CalcularArea() para cada figura.

El resultado de este código es el siguiente:

25
100

Ejemplo 2:

public class Animal {
    public abstract void Comer();
}

public class Perro : Animal {
    public override void Comer() {
        // ...
    }
}

public class Gato : Animal {
}

public class Main {
    public static void Main(string[] args) {
        List<Animal> animales = new List<Animal>();
        animales.Add(new Perro());
        animales.Add(new Gato());

        foreach (Animal animal in animales) {
            animal.Comer();
        }
    }
}

En este ejemplo, la clase Animal es abstracta, y las clases Perro y Gato la extienden.

La clase Perro cumple el principio LSP, ya que puede sustituir a la clase Animal sin afectar al funcionamiento del programa. Sin embargo, la clase Gato no cumple el principio LSP, ya que no tiene la misma implementación del método Comer() que la clase Animal.

Por ejemplo, en el método Main(), se crea una lista de animales que contiene un perro y un gato. Luego, se itera por la lista y se llama al método Comer() para cada animal.

Si se ejecuta este código, se producirá un error en el momento en que se intente llamar al método Comer() en el gato.

Este ejemplo ilustra la importancia de que las clases derivadas conserven el comportamiento de su clase base.

Como se puede ver en estos ejemplos, el principio LSP puede aplicarse a cualquier tipo de código, desde clases simples hasta sistemas complejos.