Evitar repetidas llamadas a Metodos, Persistencia y herencia seria la solucion???????

[aries_19_mad]

Buen dia:

Una pregunta si una clase se conecta a un Bd y otras clases son hijas de ella y otras subclases son hijas de las hijas de ella habria alguna forma de no repetir la conexion mediante la herencia y como seria...???
por ejm : si es una clase Sistem --> User ---> UserAdm y sistem se conecta a la BD y si su hijo User hace consultas y el sub hijo UserAdm tambien lo hace como no repetir la conexion... en el modelo del Sistema??????

[abimaelrc]

Eso lo puedes lograr usando parent sin necesidad de instanciar.

[aries_19_mad]

Tendria que poner parent en cada constructor de cada una de las clases hijas???? pero si creo la conexion a la BD en el constructor padre los hijos no derian tambien estar conectados a la BD????????

[abimaelrc]

A lo que me refiero es algo así

Código PHP:

<?php
class classConnectDb{
    private $mysql_host;
    private $mysql_user;
    private $mysql_pass;
    private $mysql_db;
    protected $connect_db;
 
    public function __construct($host, $user, $pass, $db){
        $this->mysql_host = $host;
        $this->mysql_user = $user;
        $this->mysql_pass = $pass;
        $this->mysql_db = $db;
    }
 
    public function connectDb(){
        $this->connect_db = mysql_connect($this->mysql_host, $this->mysql_user, $this->mysql_pass) or die(mysql_error());
        mysql_select_db($this->mysql_db,$this->connect_db);
    }
}
 
class query extends classConnectDb{
    protected $mysql_query;
 
    public function __construct($host, $user, $pass, $db){
        parent::__construct($host, $user, $pass, $db);
    }
 
    public function query($query){
        $this->mysql_query = mysql_query($query, $this->connect_db) or die(mysql_error());
    }
}
 
class fetch extends query{
    public function __construct($host, $user, $pass, $db){
        parent::__construct($host, $user, $pass, $db);
    }
 
    public function fetchQuery(){
        return mysql_fetch_assoc($this->mysql_query);
    }
}
 
$obj = new fetch('hostname','username','password','database');
$obj->connectDb();
$obj->query('SELECT * FROM tabla');
while($row = $obj->fetchQuery()){
    var_dump($row);
}
 

[aries_19_mad]

Ah... Esta mas entendible... Pero esto lo haces explicitamente en cada clase hija,...no deveria de ser automatico... si ya el padre ya se conecto... los hijos tmb deveria estarlo implicitamente??
creo que en java es asi... el hijo llama al constructor del padre... de manera implicita o me equivoco??? o para PHP no hay de otra que hacerlo de la manera como me has indicado????

Uhmmm... para esto ... si ejecuto la funcion de conexion en la clase padre?? asi:

Código PHP:

  class classConnectDb{

    private $mysql_host;
    private $mysql_user;
    private $mysql_pass;
    private $mysql_db;
    protected $connect_db;
 
    public function __construct($host, $user, $pass, $db){
        $this->mysql_host = $host;
        $this->mysql_user = $user;
        $this->mysql_pass = $pass;
        $this->mysql_db = $db;
        connectDb();    // se agrego
    }
 
    private function connectDb(){ ... }  // se cambio a private
} 
   

Con esto de manera implicita las clases hijas estarian conectadas ya????
o no seria asi..???

[abimaelrc]

Si te fijas bien en la instancia

Código PHP:

$obj = new fetch('hostname','username','password','database');
 

llamé al nieto (si es que se puede decir de esa forma). Todas los métodos se llamaron implicitamente, es decir desde el nieto llamé los metodos del abuelo (si es que podemos decirlo de esta forma) y del padre. Te expongo otro ejemplo para que quedes claro

Código PHP:

<?php
class fooBarCandy{
    private $bar;
 
    public function __construct($bar){
        $this->bar = $bar;
    }
 
    public function bar(){
        return $this->bar;
    }
}
 
class fooBar extends fooBarCandy{
    private $candy;
 
    public function candy($candy){
        return $this->candy = $candy;
    }
}
 
class foo extends fooBar{ 
 
}
 
$obj = new foo('fooBarCandy');
echo $obj->bar() . '<br />';
echo $obj->candy('fooBar');
 

Si te fijas la clase nieta no tiene nada y desde la clase nieta llamo tanto los método de la clase padre y la clase abuelo, porque ya están declaradas implicitamente.

Ahora en el primer ejemplo que te indique el único método que no llamé implícito es el de __contruct porque me daba un error (Warning: mysql_query() expects parameter 2 to be resource, null given in ....... on line 26) en la parte del query, pero si le coloco el constructor como te indiqué funciona correctamente. Entonces me gustaría saber ¿por qué en el primer ejemplo que expongo, tengo que forzosamente indicarle el __construct de la clase abuela a la clase padre? ¿No es de suponer que lo tome implícitamente? Eso sí, no es necesario indicar, en el primer ejemplo, la última clase el __construct.

En fin el primer ejemplo se puede hacer de esta forma sin errores:

Código PHP:

<?php
class classConnectDb{
    private $mysql_host;
    private $mysql_user;
    private $mysql_pass;
    private $mysql_db;
    protected $connect_db;
 
    public function __construct($host, $user, $pass, $db){
        $this->mysql_host = $host;
        $this->mysql_user = $user;
        $this->mysql_pass = $pass;
        $this->mysql_db = $db;
    }
 
    public function connectDb(){
        $this->connect_db = mysql_connect($this->mysql_host, $this->mysql_user, $this->mysql_pass) or die(mysql_error());
        mysql_select_db($this->mysql_db,$this->connect_db);
    }
}
 
class query extends classConnectDb{
    protected $mysql_query;
 
    public function __construct($host, $user, $pass, $db){
        parent::__construct($host, $user, $pass, $db);
    }
 
    public function query($query){
        $this->mysql_query = mysql_query($query, $this->connect_db) or die(mysql_error());
    }
}
 
class fetch extends query{ 
    public function fetchQuery(){
        return mysql_fetch_assoc($this->mysql_query);
    }
}
 
$obj = new fetch('hostname','username','password','database');
$obj->connectDb();
$obj->query('SELECT * FROM tabla');
while($row = $obj->fetchQuery()){
    var_dump($row);
}
 

[enriqueplace]

Conceptualmente estás equivocado, partamos desde ahí (no es mayor problema, se puede arreglar )

Solo puede haber herencia si hay una relación de parentesco, por lo tanto lo único que podría haber es una clase genérica BaseDeDatos y luego clases hijas que especialicen este clase, como ser MySQL, PostgreSQL, etc.

Lo que sí podría haber es una relación de uso entre una clase que quiera hacer persistencia, es decir: Usuario -> BaseDeDatos, ya que la clase Usuario quiere hacer uso de la funcionalidad de persistencia.

El diseño podría ser el siguiente:



Solo habría herencia cuando hay una relación de parentesco, como por ejemplo Admin, donde heredaría de la clase Usuario y de paso, como la clase Usuario ya maneja su persistencia, la clase Admin lo haría (pero no es "la razón de la herencia", es la consecuencia de la misma; no estamos haciendo herencia para poder reusar la persistencia, solo porque necesitas crear una nueva entidad que se basa en Usuario pero tienen algunas particularidades que necesitas diferenciar).

Pero herencia nunca es "reuso mecánico", tienes que pensar en todo esto con UML y analizar bien las relaciones antes de codificar, como quién hace un diagrama DER / MER en base de datos.

[abimaelrc]

Claro, sé que conceptualmente es un desastre. Pero contestando la pregunta específicamente, sobre si los métodos son llamados implícitamente sobre los hijos, entiendo que así es. El problema es más bien en el ejemplo que indiqué.

Tenemos una clase llamada classConnectDb, luego otra clase hija llamada query y luego otra clase nieta (si es que se puede decir de esa forma) llamada fetch. Si llamo desde la clase nieta todos los métodos de la clase padre y la del abuelo ( sigo diciendo, si es que podemos llamarla de esa forma) me salta un error (Warning: mysql_query() expects parameter 2 to be resource, null given in ....... on line 26), entonces lo que hice fue colocar estas líneas en la clase query

Código PHP:

public function __construct($host, $user, $pass, $db){
    parent::__construct($host, $user, $pass, $db);
}
 

Y funciona perfectamente. Ahora mi pregunta es, ¿por qué, en este ejemplo, tengo que colocar el constructor en la clase padre forzosamente para que funcione el código si con el segundo ejemplo, funciona sin necesidad de indicar el constructor en la clase de padre?

Este es el segundo ejemplo

Código PHP:

<?php
class fooBarCandy{
    private $bar;
 
    public function __construct($bar){
        $this->bar = $bar;
    }
 
    public function bar(){
        return $this->bar;
    }
}
 
class fooBar extends fooBarCandy{
    private $candy;
 
    public function candy($candy){
        return $this->candy = $candy;
    }
}
 
class foo extends fooBar{ 
 
}
 
$obj = new foo('fooBarCandy');
echo $obj->bar() . '<br />';
echo $obj->candy('fooBar');