Is subclass inherits private members from parent class?

Question

I have two questions related to OOP Inheritance object :

1. The first one is that according to the below code:

   class Test {
   
   private $name = "Youhana";
   
       function getPrivate(){
           echo   $this->name ;
       }
   
   }
   
   Class Test2 extends Test {
   
   }
   $obj2 = new Test2();
   $obj2->getPrivate();
   

The result will be => Youhana, but how does this work, despite the inheritance means that members are cloned from the parent to child, so if this is correct, the code in the child class must be like the below logic:

 Class Test2 {// simple imagination to the Test2 after extends Test CLass
      function getPrivate(){ //which must return null not the value of the private member.
        echo   $this->name ;
      }
}

Ref : Manual

2. Second question is that consider the below code:

    Class Ex1{
   
       function checkClassName(){
           var_dump(__CLASS__); 
       }
   }
   
   Class Ex2 extends Ex1{
   
   }
   
   
   $obj2 = new Ex2();
   
   $obj2->checkClassName();//how this will return EX1 although we invoked this function from the second object which after the inheritance will have a clone of public and protected members of the parent class?
   

How this will return EX1 although we invoked this function from the second object which after the inheritance will have a clone of public and protected members of the parent class?

Answer 1

When you extend from a superclass, nothing gets "cloned". That's the wrong way to look at this. The class is basically a template for creating an instance.

The private attributes in the superclass are visible only to the methods, that have been defined in that superclass. That's why it is called "visibility".

The private attributes are still there, when you create a child class. They are just not visible from the methods, that have been defined in the child class.

class Foo {
    private $x = 1;        
    public function check() {
        return $this->x;
    }
}

class Bar extends Foo {
    public $x = 2;
}

class Buz extends Foo {
    private $x = 3;
    public function check() {
        return $this->x;
    }
}

$n = new Bar;
var_dump($n); /*
 object(Bar)#1 (2) {
   ["x"]=>
   int(2)
   ["x":"Foo":private]=>
   int(1)
 } */
var_dump($n->check()); // int(1)

$k = new Buz;
var_dump($k->check()); // int(3)

https://3v4l.org/KkTD2

When you extend a class, you are are creating a specialized subtype case, which should be still compatible with the original superclass. The point of private, when used with extend, is to defined the parts, that will not be subject to any changes in behavior.

As for __CLASS__, it is a "magic constant" (implying, that is not actually constant-ish), that being determined by the context in which it gets accessed. It will give you the name of class, inside of which it then __CLASS__ was written.

Though, I have no idea, what you were trying to do with it, since you should not it in production code.

Answer 2

I wanna to explain about Cloning concept.

Assume, we have classA with 3 attributes:

 - private int x
 - protected int y
 - public int z

Then we have a ClassB that inherited from ClassA.

In this case, we use Cloning as Structural Cloning. Means that all attributes and methods of parent class clone into child class. We can prove it with by getting the size of child class instances.

But, their is accessing strategy. This is Encapsulation in OOP.

ClassB has x,y,z attributes. But it do not access to x. (because of encapsulation)

The structural cloning concept is important at runtime. In runtime, there is not any relationship between child and parent. The all structure of parent cloned to child. In the child class, we can access to this cloned part with keywords like super (in java) and base (in C#) and etc.

Finally as I said, In child classes, we have private members of parent class. And we can access them with provided keywords by language. But, we can not access the privates, because of Encapsulation Principle.