通过合同设计(DBC)违反了利斯科夫替代原则(LSP)？

Question

abstract class AbstractVehicle {}

abstract class AbstractFuelledVehicle extends AbstractVehicle
{
    private $lastRefuelPrice;

    final public function refuelVehicle(FuelInterface $fuel)
    {
        $this->checkFuelType($fuel);
        $this->lastRefuelPrice = $fuel->getCostPerLitre;
    }

    abstract protected function checkFuelType(FuelInterface $fuel);
}

abstract class AbstractNonFuelledVehicle extends AbstractVehicle { /* ... */ }

现在，让我们来看看“燃料”类：

abstract class AbstractFuel implements FuelInterface
{
    private $costPerLitre;

    final public function __construct($costPerLitre)
    {
        $this->costPerLitre = $costPerLitre;
    }

    final public function getCostPerLitre()
    {
        return $this->costPerLitre;
    }
}

interface FuelInterface
{
    public function getCostPerLitre();
}

以上是完成的所有抽象类，现在让我们看看具体的实现。首先，fuel的两个具体实现，包括一些贫血接口，以便我们可以正确地键入-提示/嗅探它们：

interface MotorVehicleFuelInterface {}

interface AviationFuelInterface {}

final class UnleadedPetrol extends AbstractFuel implements MotorVehicleFuelInterface {}

final class AvGas extends AbstractFuel implements AviationFuelInterface {}

最后，我们有了车辆的具体实现，它确保使用正确的燃料类型（接口）为特定的车辆类别加油，如果不兼容则抛出异常：

class Car extends AbstractFuelledVehicle
{
    final protected function checkFuelType(FuelInterface $fuel)
    {
        if(!($fuel instanceof MotorVehicleFuelInterface))
        {
            throw new Exception('You can only refuel a car with motor vehicle fuel');
        }
    }
}

class Jet extends AbstractFuelledVehicle
{
    final protected function checkFuelType(FuelInterface $fuel)
    {
        if(!($fuel instanceof AviationFuelInterface))
        {
            throw new Exception('You can only refuel a jet with aviation fuel');
        }
    }
}

null

Answer 1

将评论组合成一个答案...

我同意对LSP的分析：最初的版本是一种违反，我们总是可以通过削弱等级制度顶端的契约来解决LSP违反。然而，我不认为这是一个优雅的解决方案。类型检查总是一种代码味道（在OOP中）。用OP自己的话来说，“...包括一些贫血的界面，以便我们可以键入-提示/嗅闻它们...”这里被嗅出的是糟糕设计的恶臭。

我的观点是LSP是这里最不受关注的；instanceof是一种OO代码气味。在这里，遵守LSP就像在腐烂的房子上涂上新漆：它可能看起来很漂亮，但基础从根本上来说仍然不牢固。从设计中消除类型检查。只有担心LSP。