Obtener variables de una clase

[lolocripto]

Hola amigos!!

Tengo una clase llamada A

class A{
private $a
}

class B extends A{
private $b
}


Os planteo la siguiente pregunta, como puedo obtener las variables de la clase B?

es decir quiero saber las propiedades de la clase B (serian $a y $b), pero al ser privada $a puedo obtener usando get_class_vars. Saben otra forma de hacerlo

[anarkes]

Puedes hacerla publica, o crear un método que regrese su valor

[pateketrueke]

Las propiedaddes y métodos privados no se heredan, por lo tanto desde B no puedes conocer la existencia de las variables privadas de A.

Código PHP:

  <?php 
 
class A{ 
private $a = 'x'; 
} 
 
class B extends A{ 
private $b = 'y'; 
} 
 
$x = new B; 
 
var_dump($x); 
var_dump($x->a); 
var_dump(get_object_vars($x));   

[maycolalvarez]

si declaras variables con ámbito privado sólo pueden ser accedidas desde la misma clase (encapsulación), para poder acceder a su contenido o las declaras como publicas (public) o le creas un getter.

por otro lado las variables protegidas (protected) son en esencia privadas, cuya única diferencia radica en que pueden ser accedidas desde clases extendidas, es decir, que hereden a la misma.

[lolocripto]

Anarkes: Las propiedades de A las quiero privadas, y tengo metodo publicos... Pero estoy creando una funcion de manera que sea dinamica, pero para ello necesito acceder a las propiedades de B. Imaginate que quiero hacer un toString de tal forma que miro las propiedes y genero el nombre del metodo tal que asi getPropiedad. No quiero acceder a las propiedes privadas, quiero saber el nombre de la propiedad. Por ello uso get_class_vars.

Pateketrueke: Si B hereda de A, es que B es de tipo A y contiene las misma propiedades de A. Una cosa es el acceso, evidentemente no puedo hacer lo que tu estas diciendo. Pero puedo usar metodos publicos en A para acceder. Es decir que las propiedades si se heredan en cierta forma. Lo unico es el acceso.

[lolocripto]

okis gracias, maycolalvarez. De todas formas yo no estoy accediendo en ningun momento a las variables. Yo lo que quiero es el nombre de las propiedades de B. Una cosa distinta es que php para saber el nombre de las propiedades tenga que ponerlo en protected como tu estas diciendo

[GatorV]

Usa Reflection => getProperties.

Saludos.

[lolocripto]

Hola GatorV,

Te explico con Reflection puedo entrar a las propiedades de cualquier clase es decir que si pongo...

$reflect = new \ReflectionClass("A");
$props = $reflect->getProperties();
var_dump($props);

Esto me devuelve las propiedades privadas, publicas y protected de A, pero si yo hago
$reflect = new \ReflectionClass("B");
$props = $reflect->getProperties();
var_dump($props);

No me saca las propiedades de A, pero mi pregunta es si la clase B es una herencia de A, php no deberia devolver tambien las propiedades de A?

Quizas me digas que usando get_parent_class, podria saber las clase padres y asi saber las propiedades, pero que pasa si hay una herencia de profundidad 3, es decir C hereda de B y B hereda de A. Por la propiedad de transitividad C es tambien de tipo A.

La funcion get_parent_class me da los padres directos es decir profundidad 2 o tambien los de profundidad 3. ??

[maycolalvarez]

tampoco soy un experto en POO, pero si B hereda de A no quiere decir que las propiedades privadas de A sean vistas por B, porque el principio de encapsulación no se lo permite, para ello es protected.

si esto es así, me imagino que en otros lenguajes debe de ser similar, y si lo llevamos a la vida cotidiana un hijo hereda características físicas de su padre (public), y también otras no tan tangibles como su carácter y personalidad (protected), pero NO hereda su memoria y experiencias (private); es una analogía muy somera, pero creo que se adapta perfectamente al principio de POO

corrijanme si me equivoco

[lolocripto]

B hereda de A y no puede acceder al valor de las propiedades privadas de A. Hasta ahi estoy de acuerdo. Pero no tiene nada que ver eso, con acceder al nombre las propiedades de A, es decir si A tiene una propiedad llamada $nombre, y llamada $apellido. Desde B no quiero acceder al valor de $nombre y $apellido.

Lo que quiero hacer es que desde B sepas como se llaman las propiedades es decir se llamarian nombre y apellido.

Porque de esta manera haciendo un 'get'.nombre() puedo acceder al valor privado de la propiedad, es por eso que lo quiero automatizar. Porque quiero una funcion en B que me devuelva todas sus propiedades por ejemplo un toSTring() y no tener que poner un getNombre() y un getApellido()...

Estamos confundiendo conceptos. Esta claro que si una es privada no puedes acceder a su valor, pero quien dice que no puedas acceder al nombre de como se llama la propiedad.

[GatorV]

El problema es que la propiedad privada no se hereda, por lo mismo de que es privada, como el ejemplo que expuso @maycolalvarez, ve este ejemplo:

Código PHP:

<?php
class A
{
    private $_nombre = 'Soy A';
    public function getNombre()
    {
        return $this->_nombre;
    }
}
 
class B extends A
{
    private $_nombre = 'Soy B';
    
    /**
     * @override
     **/
    public function getNombre()
    {
        return $this->_nombre;
    }
    
    public function getAllNombres()
    {
        return $this->getNombre() . ' :: ' . parent::getNombre();
    }
}
 
$b = new B();
echo $b->getAllNombres(); // Soy B :: Soy A
 

Si tu clase tiene sus getters y setters puedes entonces usar getMethods de reflection para automatizar eso que quieres hacer, ve este ejemplo:

Código PHP:

<?php
class Persona
{
    private $_nombre;
    private $_apellido;
    
    public function __construct($nombre, $apellido)
    {
        $this->setNombre($nombre)
             ->setApellido($apellido);
    }
    
    public function setNombre($nombre)
    {
        $this->_nombre = $nombre;
        
        return $this;
    }
    
    public function getNombre()
    {
        return $this->_nombre;
    }
    
    public function setApellido($apellido)
    {
        $this->_apellido = $apellido;
        
        return $this;
    }
    
    public function getApellido()
    {
        return $this->_apellido;
    }
}
 
class Carpintero extends Persona
{
    private $_serruchos;
    
    public function __construct($nombre, $apellido, $serruchos)
    {
        parent::__construct($nombre, $apellido);
        $this->setSerruchos($serruchos);
    }
    
    public function setSerruchos($serruchos)
    {
        $this->_serruchos = $serruchos;
        
        return $this;
    }
    
    public function getSerruchos()
    {
        return $this->_serruchos;
    }
    
    public function serrucha()
    {
        echo 'serruchando';
    }
    
    public function __toString()
    {
        $R = new ReflectionClass($this);
        $sOutput = '';
        foreach ($R->getMethods() as $Method) {
            if (substr($Method->name, 0, 3) == 'get') {
                $sOutput .= $Method->invoke($this);
            }
        }
        
        return $sOutput;
    }
}
 
$Juan = new Carpintero('Juan', 'Fulano', 4);
echo $Juan;
 

[dashtrash]

lolocrypto,
No hay relación entre Reflection y el sistema de herencia de clases.Lo que conoce Reflection de las clases, lo toma del parser PHP, no del contexto desde el cual estés llamando a Reflection.Tú puedes hacer reflection de la clase "A", desde "B", o desde cualquier otro sitio.
Reflection te permite examinar el "catálogo de clases" existente en el parser php, no "el contexto actualmente visible".Desde ese catálogo, puedes saber que B deriva de A, pero no porque hayas llamado a Reflection desde B, sino porque cuando se parseó B.php, se introdujo en el catálogo de clases conocidas, con las variables miembro, funciones, etc, que el parser encontró definidas en la clase.

Por lo tanto, es perfectamente normal que desde "B" no veas nada de "A".Es más, hay que tener en cuenta que PHP no te obliga a declarar cada variable miembro de un objeto.La puedes crear en tiempo de ejecución.Aunque no lo he probado, no creo que Reflection sea capaz de devolverte la existencia de esas variables, aunque llamaras desde la propia clase,ya que éstas solo se conocen a nivel de instancia, no a nivel de clase (definicion), que es lo que maneja Reflection