Php，根据对象类型运行代码会导致依赖关系

Question

让我们创建一个动物类型列表：

abstract class Item
{
    public function run()
    {
        echo __FUNCTION__.'<br>';
    }
}

class Reptile extends Item
{
    public function putEgg()
    {
        echo __FUNCTION__.'<br>';
    }
}

class Mammal extends Item
{
    public function born()
    {
        echo __FUNCTION__.'<br>';
    }
}

$list = [];
for ($i = 1; $i <= 10; $i++)
{
    switch(mt_rand(1,2))
    {
        case 1 :
            $o = new Reptile();
            break;
        case 2 :
            $o = new Mammal();
            break;
    }
    $list[] = $o;
}

现在我想在其他地方列出它们：

class Test
{
    public function dump(array $list)
    {
        foreach ($list as $o)
        {
            /**
             * @var Item $o
             */
            echo '<hr>';
            echo get_class($o).':<br>';
            $o->run();
            if ($o instanceof Mammal)
            {
                $o->born();
            }
            if ($o instanceof Reptile)
            {
                $o->putEgg();
            }
        }
    }
}

(new Test())->dump($list);

现在我的问题是 Test 类与 Item 及其所有后代耦合。如果我这样重构整体：

abstract class Item
{
    public function run()
    {
        echo __FUNCTION__.'<br>';
    }

    public function isReptile()
    {
        return $this instanceof Reptile;
    }

    public function isMammal()
    {
        return $this instanceof Mammal;
    }
}

class Reptile extends Item
{
    public function putEgg()
    {
        echo __FUNCTION__.'<br>';
    }
}

class Mammal extends Item
{
    public function born()
    {
        echo __FUNCTION__.'<br>';
    }
}

$list = [];
for ($i = 1; $i <= 10; $i++)
{
    switch(mt_rand(1,2))
    {
        case 1 :
            $o = new Reptile();
            break;
        case 2 :
            $o = new Mammal();
            break;
    }
    $list[] = $o;
}

//
class Test
{
    public function dump(array $list)
    {
        foreach ($list as $o)
        {
            /**
             * @var Item $o
             */
            echo '<hr>';
            echo get_class($o).':<br>';
            $o->run();
            if ($o->isMammal())
            {
                $o->born();
            }
            if ($o->isReptile())
            {
                $o->putEgg();
            }
        }
    }
}

(new Test())->dump($list);

现在看起来更好一点，因为现在消除了 Test 和 Item 依赖项。还是因为isMammal()、isReptile()而闻起来很臭……这意味着每次产生新类型时，都应该更新Item。然而，基类知道其后代是一种不好的做法。优雅的方式是什么？

Answer 1

使用界面

定义一个接口并确保所有动物都实现它。

interface Animal {
    public function born();
}

现在所有的动物都必须实现这个并实现接口中定义的功能。

class Reptile implement Animal {
  public function born()
  {
     return 'new baby reptile';
  }
}

class Mammal implement Animal {
   public function born()
   {
     return 'new baby mammal';
   }
}

class Test {
   public function makeBaby(Animal $animal)
   {
      echo $animal->born();
   }
}

(new Test())->makeBaby(new Reptile());
(new Test())->makeBaby(new Mammal());

Answer 2

我相信，您不希望 end 方法在垂直大小上增长。我建议使用接口来分析Item 结构，而不是它的类。

<?php
/*
 * Interfaces first.
 * They will allow us to build a "contract" between calling class and
 * actual implementations. Also, only interfaces MUST be used in end class.
 */
interface ViviparousInterface
{
    public function giveBirth();
}

interface OviparousInterface
{
    public function layEgg();
}

interface SpawningInterface
{
    public function layCaviar();
}

/*
 * Now implemetation classes:
 */
abstract class Item
{
    public function run()
    {
        echo __FUNCTION__ . '<br>';
    }
}

class Reptile extends Item implements OviparousInterface
{
    public function layEgg()
    {
        echo __FUNCTION__ . '<br>';
    }
}

class Mammal extends Item implements ViviparousInterface
{
    public function giveBirth()
    {
        echo __FUNCTION__ . '<br>';
    }
}

class Fish extends Item implements SpawningInterface
{
    public function layCaviar()
    {
        echo __FUNCTION__ . '<br>';
    }
}

class ShomethingElse extends Item implements ViviparousInterface
{
    public function giveBirth()
    {
        echo __FUNCTION__ . '<br>';
    }
}

/**
 * Test class:
 */
class Test
{
    public function dump(array $list)
    {
        foreach ($list as $o)
        {
            /**
             * @var Item $o
             */
            echo '<hr>', get_class($o) . ':<br>';

            $o->run();

            /*
             * Here we do not care about actual classes.
             * We do know, that if they implement one of the interfaces,
             * then they will have required methods.
             */
            if ($o instanceof ViviparousInterface) {
                $o->giveBirth();
            } elseif ($o instanceof OviparousInterface) {
                $o->layEgg();
            } elseif ($o instanceof SpawningInterface) {
                $o->layCaviar();
            }
        }
    }
}

/*
 * Test case:
 */
$list = [];

for ($i = 1; $i <= 10; $i++)
{
    switch(mt_rand(1, 4))
    {
        case 1:
            $o = new Reptile();
            break;

        case 2:
            $o = new Mammal();
            break;

        case 3:
            $o = new Fish();
            break;

        case 4:
            $o = new ShomethingElse();
            break;
    }

    $list[] = $o;
}

(new Test())->dump($list);

最后，不管你将来有多少实际的Item后代，你的Test:dump()方法将只使用类结构分析。它将大大减少进一步的尺寸增长。

进一步阅读：

1. What is the point of interfaces in PHP?
2. Build seven good object-oriented habits in PHP

Answer 3

我找到了一个很好的解决方法。我将有同质列表：

$listReptiles = [];
$listMammals = [];
for ($i = 1; $i <= 10; $i++)
{
    switch(mt_rand(1,2))
    {
        case 1 :
            $listReptiles[] = new Reptile();
            break;
        case 2 :
            $listMammals[] = new Mammal();
            break;
    }
}

你怎么看？