mjhjmtu

Rule: private and final methods on an object will always be called directly, without consulting the override table.

This rule is baked into the engine:

/* Check if this calls a known method on $this */
if (opline->op1_type == IS_UNUSED && opline->op2_type == IS_CONST &&
 CG(active_class_entry) && zend_is_scope_known()) 
 zend_string *lcname = Z_STR_P(CT_CONSTANT(opline->op2) + 1);
 fbc = zend_hash_find_ptr(&CG(active_class_entry)->function_table, lcname);

 /* We only know the exact method that is being called if it is either private or final.
 * Otherwise an overriding method in a child class may be called. */
 if (fbc && !(fbc->common.fn_flags & (ZEND_ACC_PRIVATE

"Why", you ask? The answer is: because that's how it works. In language design, this is called "name hiding", and it's up to the language to specify how name hiding works. Take C++ for example. It has well-defined, and complex name hiding rules. PHP has its own rules. They're different from C++. But they're unique to PHP. This is just something you have to memorize about the language.

I admit the docs could better spell this out, however.

This is the behavior in most languages (by design).

If a method is private, $this->method() will call it directly (ignore the derived class's method)

If a method is virtual (this concept comes from C++, in PHP and Java, all public/protected methods are virtual), $this->method() will call the derived class's method.

Rule is rule, it is an OOP concern. For example, in OOP we may want to make sure a method never got overridden, then we can make it private. If a developer overrides it by accident, and would hence introduce weird behaviour if the parent suddenly called the child's implementation. Thanks to @deceze

I think the answer lies on the official documentation. doc here

In non-static contexts, the called class will be the class of the object instance. Since $this-> will try to call private methods from the same scope

As a note, though this could eliminate my confusion, simply saying "that is the way it is" seem not enough. Because it's weird behavior. It's not as clear as the late static binding nor respect to the called scope class C (which can be verified using get_called_class() in test() method ).

Ok let me try [Again]

Basically both methods exist side by side.

Private by design means that this thing (method or property) is not visible or accessible or writable by anything besides the class it was defined in. So children cannot use it in any way nor modify it in any way. This is the behaviour of private.

The why (the reason) behind the concept, is to guarantee a specific functionality (or value, of properties) no matter how the class is extended. This is good because when designing the Parent class we may not know how it will be used by any extending classes, and there may be functionality that is critical and should not be changed. This gives us a way to guarantee that in our code without knowing the implementation of the children.

One reason they can exist side by side, is inside of the child class when you call $this->foo() there is no ambiguity about which foo is being called as only the public version C::foo() visible to class C (the child) class.

class A 
 private function foo() 
 echo "A!";
 
 public function parentTest() 
 //if we used C::foo() from here Overriding A::foo().
 //having a concept of private would lose all meaning
 //because we would be allowing the child to modify it
 $this->foo();
 
 

class C extends A 
 public function foo() 
 echo 'C!';
 
 public function childTest() 
 //A::foo() cannot be used from here
 //so PHP knows to use C::foo()
 $this->foo(); 
 

In short there is only one Foo available to the child class C::foo(), so there is no way it can be confused with the private version A::foo() by PHP. In this way both methods can exist without the child overriding the parents method.

Don't let me confuse you more here, because in some ways the childs method does override the parents. We can see this if we call $obj->foo() from the global space. If we don't define foo in the child C then we get an error. But if we do define a public one in C it is used. Another thing that shows that it does overwrite (in some ways) is if we set the parent's copy A::foo() to be final. In this case if we try to define C::foo() we get an error as we would expect.

But (here is the important part), neither of these affect the functionality of the private stuff as far as the parent is concerned and so they do not violate the private principle.

Now for the parents call to its own private method.

This is where most people get confused and you asked:

When calling what is for all intents and purposes C::test, why does it prefer the private A::foo over the public C::foo

It doesn't because you are calling the private method from another method in the same class where the private one was defined.

If it preferred the child's method, then then there would be no point in having a private visibility because we would have just violated it by allowing the child to modify the method. In other words we would be using the child's functionality instead of that marked by private.

I will try to say the same things in a different way, maybe that will help (or it will just confuse you more...lol).

The reason you can have another method with the same name and it's own functionality (something I really don't care for and avoid) is because the parents private functionality does not enter the scope of the child class, so there is no way for PHP to get confused about what version private or public to use. It knows to use the public if not in the class it was defined in but to use the private if it is in the class it was defined in.

I hope that helps, that's the best I can do.

Because in first case you are not overriding the foo() in derived class C, because foo() is private.

But, in case two, foo() is public and is overridden by function foo() in class C

So, by basics of inheritance you can't override a private method and hence your foo() in class C has no existence in first case (keeping or deleting it does not matter) and the actual method of extended class A will be called since you have no right to override it in your class.

Try this:

public function test() 
 echo get_class($this);
 $this->foo();

In both case it will echo C , not A. So, $this is object of C which cannot override private methods of A, hence foo() of C has no use when foo() exists in class A and is private.