Cannot implement two interfaces that have the same method name

This doesn't wor开发者_如何学编程k:

interface TestInterface
{
    public function testMethod();
}

interface TestInterface2
{
    public function testMethod();
}

class TestClass implements TestInterface, TestInterface2
{

}

Gives me the error:

Fatal error: Can't inherit abstract function TestInterface2::testMethod() (previously declared abstract in TestInterface).

Is that correct? Why is this not allowed? Doesn't make sense to me.

This also happens with abstract functions, for example if you implement an interface and then inherit from a class that has an abstract function of the same name.

It appears that current PHP versions actually can do this. I've tracked the change in behavior down to this commit:

https://github.com/php/php-src/commit/31ef559712dae57046b6377f07634ad57f9d88cf#Zend/zend_compile.c

So as of php-5.3.9 the documented behavior appears to have changed.

The PHP manual says explicitly:

Prior to PHP 5.3.9, a class could not implement two interfaces that specified a method with the same name, since it would cause ambiguity. More recent versions of PHP allow this as long as the duplicate methods have the same signature.

It makes no sense to implement two interfaces containing methods with the same signatures.

The compiler cannot know if the methods actually have the same purpose - if not, it would mean that at least one of the interfaces cannot be implemented by your class.

Example:

interface IProgram { function execute($what); /* executes the given program */ }
interface ISQLQuery { function execute($what); /* executes the given sql query */ }

class PureAwesomeness implements IProgram, ISQLQuery {
    public function execute($what) { /* execute something.. but what?! */ }
}

So as you see, it's impossible to implement the method for both interfaces - and it'd also be impossible to call the method which actually implements the method from a given interface.

interface BaseInterface
{
    public function testMethod();
}

interface TestInterface extends BaseInterface
{
}

interface TestInterface2 extends BaseInterface
{
}

class TestClass implements TestInterface, TestInterface2
{
    public function testMethod()
    {
    }
}

This is not allowed, because PHP cannot be sure which interface has the method you want. In your case they are identical, but imagine if they had different parameters.

You should reconsider your application design.