更改方法签名以在PHP中实现类

有没有关于PHP缺少泛型的体面工作，这些泛型允许静态代码检查以检测类型一致性？

我有一个抽象类，我想对其进行子类化，并且还强制其中一种方法从采用一种类型的参数更改为采用作为该参数的子类的参数。

abstract class AbstractProcessor {
    abstract function processItem(Item $item);
}

class WoodProcessor extends AbstractProcessor {
    function processItem(WoodItem $item){}
}

PHP不允许这样做，因为它正在更改不允许的方法签名。使用Java样式泛型，您可以执行以下操作：

abstract class AbstractProcessor<T> {
    abstract function processItem(T $item);
}

class WoodProcessor extends AbstractProcessor<WoodItem> {
    function processItem(WoodItem $item);
}

但是很明显，PHP不支持这些功能。

谷歌针对这个问题，人们建议使用instanceof在运行时检查错误，例如

class WoodProcessor extends AbstractProcessor {
    function processItem(Item $item){
        if (!($item instanceof WoodItem)) {
            throw new \InvalidArgumentException(
                "item of class ".get_class($item)." is not a WoodItem");
        } 
    }
}

但这仅在运行时有效，它不允许您使用静态分析检查代码中的错误-因此，在PHP中是否有任何明智的处理方式？

该问题的一个更完整的示例是：

class StoneItem extends Item{}
class WoodItem extends Item{}

class WoodProcessedItem extends ProcessedItem {
    function __construct(WoodItem $woodItem){}
}

class StoneProcessedItem extends ProcessedItem{
    function __construct(StoneItem $stoneItem){}
}

abstract class AbstractProcessor {
    abstract function processItem(Item $item);

    function processAndBoxItem(Box $box, Item $item) {
       $processedItem = $this->processItem($item);
       $box->insertItem($item);
    }

    //Lots of other functions that can call processItem
}

class WoodProcessor extends AbstractProcessor {
    function processItem(Item $item) {
        return new ProcessedWoodItem($item); //This has an inspection error
    }
}

class StoneProcessor extends AbstractProcessor {
    function processItem(Item $item) {
        return new ProcessedStoneItem($item);//This has an inspection error
    }
}

因为我只传递了一个Itemto new ProcessedWoodItem($item)并且它期望将WoodItem作为参数，所以代码检查表明存在错误。

您可以使用不带参数的方法，而用doc-blocks记录参数：

<?php

class Foo
{
    /**
     * @param string $world
     */
    public function hello()
    {
        list($world) = func_get_args();

        echo "Hello, {$world}\n";
    }
}

class Bar extends Foo
{
    /**
     * @param string $greeting
     * @param string $world
     */
    public function hello()
    {
        list($greeting, $world) = func_get_args();

        echo "{$greeting}, {$world}\n";
    }
}

$foo = new Foo();
$foo->hello('World');

$bar = new Bar();
$bar->hello('Bonjour', 'World');

我不会说我认为这是个好主意。

您的问题是，您的上下文具有可变数量的成员-而不是试图通过强制将这些成员作为参数，而是一种更好且更具前瞻性的想法是引入一个上下文类型来携带所有可能的参数，以便该参数列表永远不需要更改。

像这样：

<?php

class HelloContext
{
    /** @var string */
    public $greeting;

    /** @var string */
    public $world;

    public static function create($world)
    {
        $context = new self;

        $context->world = $world;

        return $context;
    }

    public static function createWithGreeting($greeting, $world)
    {
        $context = new self;

        $context->greeting = $greeting;
        $context->world = $world;

        return $context;
    }
}

class Foo
{
    public function hello(HelloContext $context)
    {
        echo "Hello, {$context->world}\n";
    }
}

class Bar extends Foo
{
    public function hello(HelloContext $context)
    {
        echo "{$context->greeting}, {$context->world}\n";
    }
}

$foo = new Foo();
$foo->hello(HelloContext::create('World'));

$bar = new Bar();
$bar->hello(HelloContext::createWithGreeting('Bonjour', 'World'));

静态工厂方法当然是可选的-但如果只有某些特定的成员组合产生有意义的上下文，它可能会很有用。如果是这样，您不妨同时声明__construct()为受保护/私有。