里氏替换原则

里氏替换原则（Liskov Substitution Principle）指的是，如果一个父类可以被子类继承，那么这个父类对象可以被替换成子类对象，而不影响程序的正确性。换句话说，子类对象应该能够替换父类对象，并且保证程序的行为结果一致。这个原则是面向对象设计五大原则（SOLID）中的一条。

为了满足里氏替换原则，子类需要符合父类的契约，也就是说子类需要保证实现父类中的所有方法，并且方法的前置条件（方法的输入条件）和后置条件（方法的输出条件）与父类保持一致或更加严格。如果子类不能满足父类的契约，那么子类就不应该继承父类。

以下是一个 Java 代码示例，其中 Rectangle 是一个父类，而 Square 是一个子类。Square 继承自 Rectangle，并且重写了父类的 setWidth 和 setHeight 方法。注意，在 Square 中重写的 setWidth 和 setHeigt 方法的前置条件更加严格（要求宽高相等），但是程序的输出结果依然正确。

class Rectangle {
    protected double width;
    protected double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

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

    public double getHeight() {
        return height;
    }

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

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

class Square extends Rectangle {
    public Square(double side) {
        super(side, side);
    }

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

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

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(3, 4);
        Square square = new Square(5);

        useRectangle(rectangle);
        useRectangle(square);
    }

    public static void useRectangle(Rectangle rectangle) {
        rectangle.setWidth(6);
        rectangle.setHeight(8);

        System.out.println("Width: " + rectangle.getWidth());
        System.out.println("Height: " + rectangle.getHeight());
        System.out.println("Area: " + rectangle.getArea());
    }
}

输出结果：

Width: 6.0
Height: 8.0
Area: 48.0
Width: 5.0
Height: 5.0
Area: 25.0

可以看到，即使我们用 Square 对象替换了 Rectangle 对象，程序依然输出了正确的结果，这就说明了这个例子满足里氏替换原则。