了解Liskov替代原则

Liskov替代原则是SOLID五大原则之一，LSP由Barbara Liskov提出。Liskov替代原则定义了超类的对象必须可以被其子类的对象替代而不破坏应用。这意味着子类的对象必须与超类的对象有相同的行为方式。

例如，狗类是动物类的一个子类，我们应该能够将狗类的对象传递给任何期望有动物类对象的方法，在这种情况下，该方法不应该给出任何奇怪的输出。

LSP扩展了开放-封闭原则，也关注了超类及其子类的行为。

这是预期的行为，因为当我们使用继承时，我们假设子类继承了超类的一切。子类扩展了行为，但从未缩小其范围。

让我们看一个遵循Liskov替代原则规则的例子。

class Vehicle {
    String name;
    int speed;
    public Vehicle(String name, int speed) {
        this.name = name;
        this.speed = speed;
    }
    public void start() {
        System.out.println(name + " is running with speed "+speed);
    }
}

我们有一个车辆类和start()方法，它可以打印出车辆的名称和速度。

现在我们决定有一些子类，如Cycle、Bike和Car。

class Cycle extends Vehicle {
    public Cycle(String name, int speed) {
        super(name, speed);
    }
    @Override
    public void start() {
        super.start();
    }
}

class Bike extends Vehicle {
    public Bike(String name, int speed) {
        super(name, speed);
    }
    @Override
    public void start() {
        super.start();
    }
}

class Car extends Vehicle {
    public Car(String name, int speed) {
        super(name, speed);
    }
    @Override
    public void start() {
        super.start();
    }
}

让我们创建一个主类来对start() 函数进行测试。测试类有一个startVehicle()方法，它以Vehicle类对象为参数并执行操作。因此，你可以提供任何子类的对象，例如Car、Bike和Cycle类的对象，因为这些类扩展了Vehicle类。

public class Test {
    public void startVehicle(Vehicle vehicle) {
        vehicle.start();
    }
    public static void main(String[] args) {
        Vehicle bike = new Bike("Bike", 60);
        Vehicle cycle = new Cycle("Cycle", 30);
        Vehicle car = new Car("Car", 80);
        Test test = new Test();
        test.startVehicle(cycle);
        test.startVehicle(bike);
        test.startVehicle(car);
    }
}

输出

单车以30的速度运行
自行车以60的速度运行
汽车以80的速度运行

LSP的现实世界的例子。