Strange behavior when overriding private methods

Question

Consider the following piece of code:

class foo {
    private function m() {
        echo \'foo->m() \';
    }
    public function call() {
        $this-         


        

Answer 1

Inheriting/overriding private methods

In PHP, methods (including private ones) in the subclasses are either:

• Copied; the scope of the original function is maintained.
• Replaced ("overridden", if you want).

You can see this with this code:

callH();

Now if you override the private method, its new scope will not be A, it will be B, and the call will fail because A::callH() runs in scope A:

callH(); //fatal error; call to private method B::h() from context 'A'

Calling methods

Here the rules are as follows:

• Look in the method table of the actual class of the object (in your case, bar).
  • If this yields a private method:
    • If the scope where the method was defined is the same as the scope of the calling function and is the same as the class of the object, use it.
    • Otherwise, look in the parent classes for a private method with the same scope as the one of the calling function and with the same name.
    • If no method is found that satisfies one of the above requirements, fail.
  • If this yields a public/protected method:
    • If the scope of the method is marked as having changed, we may have overridden a private method with a public/protected method. So in that case, and if, additionally, there's a method with the same name that is private as is defined for the scope of the calling function, use that instead.
    • Otherwise, use the found method.

Conclusion

1. (Both private) For bar->call(), the scope of call is foo. Calling $this->m() elicits a lookup in the method table of bar for m, yielding a private bar::m(). However, the scope of bar::m() is different from the calling scope, which foo. The method foo:m() is found when traversing up the hierarchy and is used instead.
2. (Private in foo, public in bar) The scope of call is still foo. The lookup yields a public bar::m(). However, its scope is marked as having changed, so a lookup is made in the function table of the calling scope foo for method m(). This yields a private method foo:m() with the same scope as the calling scope, so it's used instead.
3. Nothing to see here, error because visibility was lowered.
4. (Both public) The scope of call is still foo. The lookup yields a public bar::m(). Its scope isn't marked as having changed (they're both public), so bar::m() is used.