里氏替换原则（Liskov Substitution Principle，LSP）

前沿：

继承性的思考？

继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。

继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障。

那该如何使用继承呢？

里氏替换原则：

里氏替换原则(Liskov Substitution Principle)在 1988 年，由麻省理工学院的Barbara Liskov提出的，他是关于继承和多态的原则，它指导子类如何与父类进行交互，以保持系统的稳定性和可扩展性。

 里氏替换原则的定义如下：如果对于每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。

换句话说，子类对象应该能够替换父类对象并且不会产生任何错误或异常，而且程序的行为应该保持一致。这意味着子类必须遵守父类的约定、契约和行为，并且可以通过扩展父类的功能而不是修改它。

遵循里氏替换原则的好处包括：

1. 代码重用：通过继承和多态，可以重用父类的代码，减少冗余代码的编写。

2. 可扩展性：通过扩展父类，可以增加新的功能和行为，而不需要修改已有的代码。

3. 模块化和松耦合：通过定义抽象的父类和接口，可以实现模块化和松耦合的设计，提高代码的可维护性和可测试性。

class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getArea() {
        return width * height;
    }
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width;
    }

    @Override
    public void setHeight(int height) {
        this.width = height;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(5);
        rectangle.setHeight(10);
        System.out.println("Rectangle area: " + rectangle.getArea());

        Rectangle square = new Square();
        square.setWidth(5);
        square.setHeight(10); // 违反了里氏替换原则
        System.out.println("Square area: " + square.getArea());
    }
}

在上述示例中，Rectangle 是一个矩形类，Square 是一个正方形类，它继承自矩形类。根据里氏替换原则，正方形应该能够替换矩形并且不会产生错误。然而，在代码中，当将正方形对象赋给矩形类型的变量并设置不同的宽度和高度时，会导致计算面积出现错误。这违反了里氏替换原则，因为子类的行为与父类的行为不一致。

为了符合里氏替换原则，可以重新设计类的继承关系或采用其他的设计模式来处理不一致的行为。

为了重新设计一个符合里氏替换原则的类结构，可以考虑将矩形和正方形的关系转化为更合适的对象模型。一种可能的方案是引入一个抽象的形状（Shape）类，作为矩形和正方形的共同父类。然后，通过多态和动态绑定来实现不同形状的特定行为。以下是一个示例：

abstract class Shape {
    public abstract int getArea();
}

class Rectangle extends Shape {
    protected int width;
    protected int height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    @Override
    public int getArea() {
        return width * height;
    }
}

class Square extends Shape {
    protected int side;

    public void setSide(int side) {
        this.side = side;
    }

    @Override
    public int getArea() {
        return side * side;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape rectangle = new Rectangle();
        ((Rectangle) rectangle).setWidth(5);
        ((Rectangle) rectangle).setHeight(10);
        System.out.println("Rectangle area: " + rectangle.getArea());

        Shape square = new Square();
        ((Square) square).setSide(5);
        System.out.println("Square area: " + square.getArea());
    }
}

在上述示例中，我们引入了一个抽象的 Shape 类作为矩形和正方形的父类。每个子类都实现了 Shape 类的抽象方法 getArea()，以计算特定形状的面积。通过使用抽象类和方法，我们确保了子类必须实现父类定义的行为，遵循里氏替换原则。

在 main() 方法中，我们创建了一个矩形对象和一个正方形对象，并分别调用它们的特定方法来设置参数。通过统一使用父类类型的变量，我们可以进行多态调用，而无需关心具体子类的类型。这样，我们可以保持代码的一致性和可扩展性。

重新设计后的类结构符合里氏替换原则，子类对象可以替换父类对象，并且程序的行为保持一致。这样的设计模式有助于提高代码的可维护性、可扩展性和灵活性。