What is going on here in PHP with classes?

Question

If I have this code, the string "test" is echoed. This is in PHP 5.3. Is this some oversight that shouldn't be relied on, or is it some way of achieving multiple inheritence in PHP?

class Test1
{
    function getName()
    {
        return $this->name;
    }
}

class Test2
{
    public $name = 'test';

    function getName()
    {
        return Test1::getName();
    }
}

$test = new Test2;
echo $test->getName();

EDIT:

As has been pointed out the comments by GZipp this is actually documented behaviour. See this page: http://us2.php.net/manual/en/language.oop5.basic.php and the heading "Example #2 Some examples of the $this pseudo-variable".

Classes A and B have a similar relationship to my two test classes above and the lines

$b = new B();
$b->bar();

Show more or less the same result as my example.

Answer 1

Just to be clear - this isn't inheritance. Test2 does not extend Test1. You statically referenced a public method of the Test1 class.

Nonetheless, the fact that it returns 'test' is interesting to say the least. And I see where it is giving off the idea of inheritance.

If you can't find a decent answer, I'd submit your code as a bug.

UPDATE

It looks like under the hood, even though you statically referenced a method of Test1, it's still being called as Test2. In the end, this is undefined behavior, and ask noted above does throw a strict warning. Still very odd, and I personally agree that it shouldn't work. But just to shed a little more insight which object it is using.

class Test1 {
    function getName() {
        echo get_class($this);
        return $this->name;
    }
}
// ...
$test = new Test2;
echo $test->getName();

// echoes 'Test2 test'

Answer 2

PHP allows calling non-static methods as if they were static - that's a feature. PHP passes $this as an implicit parameter to such calls. Much like it does when calling a method the normal way.

But obviously PHP doesn't check whether the statically called class inherits the current one - and that's the bug.

This is how you could think of what PHP does:

function Test1->getName($this = null) {
    return $this->name;
}

function Test2->getName($this = null) {
    return Test1->getName($this);
}

$test = new Test2;
echo $test->getName($test);

This behavior is wrong. The correct Test2->getName would be:

function Test2->getName($this = null) {
    return $this instanceof Test1 ? Test1->getName($this) : Test1->getName();
}

Answer 3

This has to be a bug. 100%.

1. This is not inheritance.
2. You should not be able to call Test1::getName() as getName() in Test1 is not static
3. Even if you could call it, $this->name should not have access to the value in Test2.

This breaks so many rules of OO I am seriously baffled how this got through testing. Well don for finding it!!