Principio de sustitución de Liskov

El Principio de Sustitución de Liskov es un concepto fundamental en la programación orientada a objetos que asegura la intercambiabilidad de clases dentro de una jerarquía. Según este principio, si una clase S es un subtipo de la clase T, entonces objetos de la clase T en un programa deberían poder ser reemplazados por objetos de la clase S sin alterar la correcta ejecución del programa. Esto significa que el uso de la subclase no debe requerir modificaciones especiales ni llevar a un comportamiento inesperado, manteniendo el “contrato” establecido por la clase base.

/** Example whitout LSP principle*/
interface Area
{
    public function setLength(int $length): self;
    public function setWidth(int $width): self;
    public function getArea(): float;
}

class Rectangle implements Area
{
    protected $length;
    protected $width;

    public function setLength(int $length): self {
        $this->length = $length;
        return $this;
    }

    public function setWidth(int $width): self {
        $this->width = $width;
        return $this;
    }

    public function getArea(): float {
        return $this->length * $this->width;
    }
}

class Triangle implements Area
{
    // The implementation for a triangle...
}

class Square implements Area
{
    protected $sideLength;

    public function setLength(int $length): self {
        $this->sideLength = $length;
        return $this;
    }

    public function setWidth(int $width): self {
        $this->sideLength = $width;
        return $this;
    }

    public function getArea(): float {
        return $this->sideLength * $this->sideLength;
    }
}

En este caso, Square se implementa de manera que viola el principio, ya que cambiar la longitud de un lado de un cuadrado implica cambiar el otro lado, lo cual no es un comportamiento esperado para un cuadrado. Si Square hereda de Rectangle, esta herencia es errónea porque altera el comportamiento fundamental de Rectangle.

/** Example with LSP principle */
class Rectangle
{
    protected $length;
    protected $width;

    public function setLength(int $length) {
        $this->length = $length;
    }

    public function setWidth(int $width) {
        $this->width = $width;
    }

    public function getArea() {
        return $this->length * $this->width;
    }
}

class Square extends Rectangle
{
    public function setLength(int $length) {
        $this->length = $length;
        $this->width = $length; // Garantizando que tanto el ancho como el largo son iguales
    }

    public function setWidth(int $width) {
        $this->length = $width; // Garantizando que tanto el ancho como el largo son iguales
        $this->width = $width;
    }
}

El uso correcto del Principio de Sustitución de Liskov asegura que las jerarquías de clase sean coherentes y que los contratos de clase se mantengan a lo largo de la herencia o implementación. Es fundamental para el diseño sólido de clases y para el mantenimiento eficiente de un código robusto. Este principio a menudo se cumple naturalmente si se están respetando los principios de SRP y OCP, especialmente este último, ya que evita la extensión de comportamientos que no coinciden con la clase base.

Para finalizar

Principios SOLID: Principio de Sustitución de Liskov LSP

el principio de sustitución de Liskov, un principio que nos dice que su tienes una clase hija, esta clase hija no debe eliminar comportamiento de la clase padre. También aplica para interfaces.

#Video tutorial#hdeleon#SOLID