Question

我有一个叫做Bird的类，它在构造函数中接受鸟的数组。我正在尝试在其中实现一个函数，该函数将检查当前是否有任何鸟在飞行，请记住所有代码都应符合SOLID原则。

我有以下两个班级（鹦鹉和鸵鸟）

class Parrot extends FlyingBirds{}   
class Ostrich extends BirdDetail{}

BirdDetail类

abstract class BirdDetail {

  protected $didNotSleepLastNight;

  public function __construct(bool $didNotSleepLastNight)
  {
    $this->didNotSleepLastNight= $didNotSleepLastNight;
  }

  public function didNotSleepLastNight(): bool
  {
    return $this->didNotSleepLastNight;
  }

}

FlyingBirds（并非所有的鸟类都能像鸵鸟一样飞翔）

abstract class FlyingBirds extends BirdDetail{

 protected $isFlyingNow;

 public function __construct(bool $didNotSleepLastNight, bool $isFlyingNow)
 {
    parent::__construct($didNotSleepLastNight);
    $this->isFlyingNow = $isFlyingNow;
 }

 public function isFlyingNow(): bool
 {
    return $this->isFlyingNow;
 }
}

然后我有一个叫做Bird的课程

class Bird
{
  private $details;

 public function __construct(array $details)
 {
    $this->details = $details;
 }

 public function didNotSleepLastNight(): bool
 {
    foreach ($this->details as $detail) {

        if ($detail->didNotSleepLastNight()) {
            return true;
        }
    }

    return false;
 }

 public function isFlyingNow(): bool
 {
    foreach ($this->details as $detail) {

        if ($detail->isFlyingNow()) 
        {
            return true;
        }
    }
    return false;
  }
}

现在我将Parrot和Ostrich的实例传递给Bird Constructor

$bird = new Bird([new Parrot(true, false), new Ostrich(false)]);     

if($bird->isFlyingNow())
{
 echo "Yes";
}
else
{
 echo "No";
}

问题是上面的代码给我以下错误

Fatal error: Uncaught Error: Call to undefined method Ostrich::isFlyingNow()

这是因为Ostrich / BirdDetail类没有名为isFlyingNow的方法。

可以通过将Birds类中的isFlyingNow方法替换为以下代码来解决此问题：

public function isFlyingNow(): bool
{

    foreach ($this->details as $detail) {

        if (method_exists($detail, 'isFlyingNow') && $detail->isFlyingNow())             
        {
            return true;
        }
    }

    return false;

}

能否请您告诉我上面的修复是否违反了SOLID原则？还是可以更好地解决问题？

Answer 1

并没有真正打破SOLID，但设计得不是很好。

对于更整洁的方法，请使用界面。

由于并非所有鸟类都能飞翔，所以对所有鸟类采用面向公众的方法isFlying()似乎很浪费。

也许您可以执行以下操作：

您的基础Bird类，您将在其中定义所有鸟类的通用属性和方法。

class Bird {
}

然后，使用不同的接口来描述Bird子类的不同可能行为。有些鸟会飞，一些会游泳，一些会说话，一些会唱歌，一些会潜水，一些会跑步等，等等。

对于传单：

interface FlyingBird {

    function isFlying():bool;

    function takeOff();

    function land();

    function fly($bearing, $distance);

}

对于谈话者：

interface TalkingBird {

    function say($something);
}

歌手：

interface SingingBird {
    function sing(array $notes);
}

游泳者（您可能需要区分那些在水面游泳的人和那些可以潜入水面以下的人）。

interface SwimmingBird {
   function isSwimming(): bool;
   // etc
}

对于跑步者：

interface RunningBird {
   function isRunning(): bool;
   // etc
}

然后，您可以参加类似Parrot的课程（飞行和交谈，但不唱歌，跑步或游泳）

class Parrot extends Bird implements TalkingBird, FlyingBird {
    // todo: actual implementation
}

或Ostrich（可以跑步，但不会游泳，唱歌，说话或飞行）：

class Ostrich extend Birds implements RunningBird { /* implementation */}

甚至Penguin（会游泳，不会飞，不会跑步，不会唱歌，不会说话）：

class Penguin extends Bird implements SwimmingBird { /* implementation */ }

等等，整个@package Ornithology的雏形。

这些类的用户应检查实例是否在实现适当的接口：

if ($birdInstance instanceof FlyingBird && $birdInstance->isFlying()) {
   echo "This bird is flying!";
}

为简化这些类的构成，您可能需要创建一些特征：

例如

trait FlyingBirdTrait {

    private $flying = false;

    function isFlying():bool {
       return $this->flying;
    }

    function takeOff() {
       $this->flying = true;
    }

    function land() {
       $this->flying = false;
    }

    function fly($bearing, $altitude, $distance) {
       if (!$this->isFlying()) {
           $this->takeOff();
       }
       // calculate new position;

    }
}

然后像Parrot这样的类可以使用：

class Parrot extends Bird implements TalkingBird, FlyingBird {
    uses FlyingBirdTrait;
    // rest of the implementation, etc;
}

Answer 2

这不违反SOLID原则。如果Bird子类拒绝继承的方法，将违反Liskov原则，但这不是您要执行的操作。

我同意您的代码虽然不是很好。一个更干净的解决方案是在Bird超类中定义一个isFlyingNow抽象方法，该方法被实现为在Ostrich和其他非飞行类中返回false。然后，您将不需要在运行时检查对象是否提供此方法。

检查类中是否存在方法是否违反SOLID原则？

2 个答案: