Php: Overriding abstract method goes wrong

I think there is a problem in php's OOP implementation.

EDIT: Consider more illustrative example:

abstract class Animal {

    public $name;

    // public function Communicate(Animal $partner) {}     // Works
    public abstract function Communicate(Animal $partner); // Gives error
}

class Panda extends Animal {

    public function Communicate(Panda $partner) {
        echo "Hi {$partner->name} I'm a Panda";
    }

}

class Human extends Animal {

    public function Communicate(Human $partner) {
        echo "Hi {$partner->name} I'm a Human";
    }

}

$john = new Human(); $john->name = 'John';
$mary = new Human(); $mary->name = 'Mary';
$john->Communicate($mary); // should be ok

$zuzi = new Panda(); $zuzi->name = 'Zuzi';
$zuzi->Communicate($john); // should give error

The problem is that when Animal::Communicate is an abstract method, php tells that the following methods are illegal:

"public function Communicate(Panda $partner)" "public function Communicate(Human $partner)"

but when Animal::Communicate is non-abstract but has zero-implementation Php thinks that these methods are legal. So in my opinion it's not right because we are doing override in both cases, and these both cases are equal, so it seems like it's a bug...

Older part of the post:

Please consider the following code:

Framework.php

namespace A
{
    class Component { ... }

    abstract class Decorator {
        public abstract function Decorate(\A\Component $component);
    }
}

Implementation.php

namespace B
{
    class MyComponent extends \A\Component { ... }
}

MyDecorator.php

namespace A
{
    class MyDecorator extends Decorator {
        public function Decorate(\B\MyComponent $component) { ... }
    }
}

The following code gives error in MyDecorator.php telling

Fatal error: Declaration of MyDecorator::Decorate() must be compatible with that of A\Decorator::Decorate() in MyDecorator.php on line ...

But when I change the Framework.php::Decorator class to the following implementation:

    abstract class Decorator {
        public function Decorate(\A\Component $component) {}
    }

the problem disa开发者_开发百科ppears.

---

I'm not sure (haven't tested it ;), but you declare this abstract function:

public abstract function Decorate(\A\Component $component);

So you should implement this EXACTLY like that. But you did this:

public function Decorate(\B\MyComponent $component) { ... }

That's not the same. Could you try to change that to \A\Component?

To all comments: fact of the matter is that this piece of PHP "runs"

namespace A
{
    class Component { }

    abstract class Decorator {
        public abstract function Decorate(\A\Component $component);
    }
}
namespace B
{
    class MyComponent extends \A\Component { }
}
namespace A
{
    class MyDecorator extends Decorator {
        public function Decorate(\A\Component $component) {}
    }

}

And this doesn't:

<?php
namespace A
{
    class Component { }

    abstract class Decorator {
        public abstract function Decorate(\A\Component $component);
    }
}
namespace B
{
    class MyComponent extends \A\Component { }
}
namespace A
{
    class MyDecorator extends Decorator {
        public function Decorate(\B\MyComponent $component) {}
    }

}
?>

With this error: PHP Fatal error: Declaration of A\MyDecorator::Decorate() must be compatible with that of A\Decorator::Decorate() in line 18

Now you can discuss all you like about how that should or should not be, but that's the problem with the code.

so, to satisfy my own curiosity: this is illegal too:

<?php
    class Component { }

    abstract class Decorator {
        public abstract function Decorate(Component $component);
    }

    class MyComponent extends Component { }
    class MyDecorator extends Decorator {
        public function Decorate(MyComponent $component) {}
    }


?>

It's not the namespaces or anything. It just doesn't seem legal.

---

See http://bugs.php.net/bug.php?id=36601, this issues has been reported as a bug but was rejected because of laziness :D

---

It has nothing to do with it being abstract. It has to do with the type hinting. The two definitions of the method are not compatible because you explicitly set the argument to be of type \A\Component and then try to overload the method with \B\Component you cant do that because it changes the method signature. Any subsequent declaration of Decorate must use the same type hint as its parent declaration in order for the method signatures to be compatible.

---

This might assist someone, and am not late. The best way to handle such is by using an interface. Consider below;

<?php
    interface Componentor{}

    class Component implements Componentor { }

    abstract class Decorator {
        public abstract function Decorate(Componentor $component);
    }

    class MyComponent extends Component { }

    class MyDecorator extends Decorator {
        public function Decorate(Componentor $component) {}
    }

?>

Usage;

<?php
    $c=new Component();
    //TODO ....blah blah blah...
    $decor=new MyDecorator();
    //TODO ....blah blah blah...
    $decor->Decorate($c);

?>