试图理解Liskov代换原理

Question

我试图理解Liskov替换原理，我有以下代码：

class Vehicle {
}

class VehicleWithDoors extends Vehicle {
    public void openDoor () {
        System.out.println("Doors opened.");
    }
}

class Car extends VehicleWithDoors {
}

class Scooter extends Vehicle {
}

class Liskov {
    public static void function(VehicleWithDoors vehicle) {
        vehicle.openDoor();
    }

    public static void main(String[] args) {
        Car car = new Car();
        function(car);
        Scooter scooter = new Scooter();
        //function(scooter);  --> compile error
    }
}

我不确定这是否违反了它。原理是，如果你有一个类S的对象，那么你可以用另一个类T的对象来代替它，其中S是T的一个子类。但是，如果我写了

Vehicle vehicle = new Vehicle();
function(vehicle);

这当然会产生编译错误，因为Vehicle类没有openDoor（）方法。但这意味着我不能用它们的父类Vehicle替换VehicleWithDoors对象，这似乎违反了原则。那么这个代码是否违反了它？我需要一个好的解释，因为我似乎不明白。

Answer 1

扩展类或接口时，新类仍然是它扩展的类型。对此进行推理的最简单方法（IMO）是将子类视为超类的一种特殊类型。所以它仍然是超类的一个实例，还有一些额外的行为。

例如，带车门的车辆仍然是车辆，但它也有车门。滑板车也是一种交通工具，但它没有门。如果您有打开车门的方法，则车辆必须有车门（因此，当您将踏板车传递给它时会出现编译时错误）。同样，对于接受某个类的对象的方法，您可以传递作为其子类实例的对象，该方法仍然可以工作。

就实现而言，您可以安全地将任何对象强制转换为其超类型之一（例如，汽车和滑板车到车辆，汽车到带门车辆），但不能反过来（如果您进行一些检查并明确地强制转换，则可以安全地执行此操作）。

Answer 2

你倒过来了。该原则规定，“如果S是T的子类型，则程序中T类型的对象可以替换为S类型的对象，而不改变该程序的任何期望属性”。

基本上，车辆应该在车辆工作的地方工作。这显然并不意味着车辆应该在车辆与门工作的地方工作。换句话说，您应该能够在不影响程序正确性的情况下用专门化替换泛化。

示例冲突是一个ImmutableList扩展一个定义add操作的List，其中不可变实现抛出异常。

js lang-js prettyprint-override">class List {
  constructor() {
    this._items = [];
  }
  
  add(item) {
    this._items.push(item);
  }
  
  itemAt(index) {
    return this._items[index];
  }
}

class ImmutableList extends List {
  constructor() {
    super();
  }
  
  add(item) {
    throw new Error("Can't add items to an immutable list.");
  }
}