Héritage PHP mysql

Version imprimable

Héritage PHP mysql

Bonjour,

Je viens vers vous car j'ai un problème concernant l'héritage ou plutôt, un truc qui m'échappe.
Pour faire simple, j'ai mon appli PHP qui est couplée avec une base MySQL, jusque la, rien d'exceptionnel.

Dans ma base, j'ai deux tables:
ma première table, nommé Personne est selon le schéma suivant : idPersonne (int), nom(varchar), prenom (varchar)
ma seconde table, nommé Collaborateur est la suivante: idCollaborateur(int), idPersonne(int), fonction(varchar), telephone(varchar)

Come on peut le voir, il y a une jointure sur le idPersonne.

Coté php, j'ai mes deux classes dans deux fichiers Personne.php et Collaborateur.php
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Collaborateur extends Personne { protected idPersonne; protected nom; protected prenom; public function __construct($idObjet = null) { //une fonction qui charge mon objet si l'ID est passé en paramètre } function getValeur($champ) { return $this->getValeur } }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Collaborateur extends Personne { protected idCollaborateur; protected idPersonne; protected fonction; protected telephone; public function __construct($idObjet = null) { //une fonction qui charge mon objet si l'ID est passé en paramètre } } {
J'ai créé un formulaire qui ajoute mon collaborateur en choisissant une personne dans la liste. Enregistrement OK.
Mais je voudrais charger un objet Collaborateur qui va, au moment de l'instanciation, charger ma Personne, et donc avoir les informations nom et prénom.

J'ai trouvé une technique qui est d'initialisation un objet Personne avec la valeur de l'idPersonne, mais je suis persuadé que je n'utilise pas l'héritage à bon escient. Je dois pouvoir récupérer mes propriétés nom et prenom depuis mon collaborateur non? N'est-ce pas le but de l'héritage?

Je précise que je débute dans le dév, donc désolé si ma question parait stupide.

Merci à vous

Je comprends pas trop ta question. Pour la forme :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Personne {
  protected $idPersonne;
  protected $nom;
  protected $prenom;
 
  public function __construct() {
	$this->idPersonne = 12;
  }
}
 
class Collaborateur extends Personne {
 
  public function getIdPersonne() {
    return $this->idPersonne;
  }
}
$a = new Collaborateur();
echo $a->getIdPersonne();// affiche 12

Oups, il arrive que parfois, j'ai du mal à m'exprimer donc à me faire comprendre... :p
Pour reprendre ton exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
class Personne {
  protected $idPersonne;
  protected $nom;
  protected $prenom;
 
  public function __construct($idBase) {
	// construction de mon objet via une requete select basée sur l'idBase"
  }
 
  public function getValeur($champ) {
    return $this->$champ;
  }
}
 
class Collaborateur extends Personne {
   protected $idCollaborateur;
   protected $idPersonne;
   protected $fonction*;
 
 
   public function  __construct($idBase) {
      $donnees = "tableau issue d'une requete MySQL basé sur l'idCollaborateur"
      $this->idCollaborateur = $donnees['idCollaborateur'];
      $this->idPersonne = $donnees['idPersonne'];
/* fonction qui intialise mes variables nom et prenom 
* la solution que j'ai trouvé est simplement:
*/
     $maPersonne = new Personne($this->idPersonne);
     $this->nom = $maPersonne->getValeur('nom');
     $this->prenom = $maPersonne->getValeur('prenom');
  }
 
  public function getValeur($champ) {
     return $this->$champ;
  }
 
 
// Fichier ou j'affiche les données
$a = new Collaborateur('12');
echo $a->getValeur('nom');// affiche le nom de mon collaborateur ayant un idPersonne chargé depuis la table collaborateur

Je trouve cette solution bizarre et je voulais savoir si je peux charger l'objet personne de façon différente

18/01/2017, 20h21
ABCIWEB

Houlà je viens de comprendre, il y a un intérêt quelconque à faire ce bin's ?

Commences plutôt par faire une requête basique. Tu verras par la suite s'il y a intérêt à faire une classe. Ne cherche pas à faire des classes juste histoire de faire des classes, c'est inutile et contreproductif si tu n'y trouves pas un intérêt et là je vois pas lequel tu pourrais trouver.

Tu essaies de créer un objet à l'image de tes tables. Or le mode objet doit servir ton script (tes requêtes), pas tes tables.

Si le but est "afficher le nom de mon collaborateur ayant un idPersonne chargé depuis la table collaborateur", fais ta requête normalement sur la table "Collaborateur" avec une jointure sur la table "Personne" et basta.

Où si tu veux faire deux requêtes fais le code en procédural puis met éventuellement les requêtes dans des fonctions distinctes pour faire une classe si tu y tiens. Mais en tous cas je ne vois pas pourquoi tu aurais besoin de deux classes dont une hérite de la première.
19/01/2017, 08h47
grunk
Je plussois ABCIWEB , faire des classes pour faire des classes n'a pas d'intérêt si un simple tableau de données peut répondre au besoin.

Deplus ton héritage n'est pas bon , puisque Personne possède déjà $idPersonne , nul besoin de le redéfinir dans Collaborateur.

J'aurais plutôt tendance à opter pour une composition plutôt qu'un héritage sauf si Collaborateur est réellement une personne spécialisée et pas une entité à part.
Code:

1 2 3 4 5 class Collaborateur { protected $personne protected fonction; protected telephone; }
Ceci étant dit pour répondre à ta question il y'a deux solutions :

1- Le collaborateur créer la personne

Dans ce cas là le fait d'instancier un collaborateur va automatiquement créer une personne.
Tu auras donc dans ta classe collaborateur une requête faisant une jointure sur tes 2 tables et remplissant les champs de personne.

Le problème avec cette solution c'est que si tu n'utilise que très rarement les infos de la personne , tu vas récupérer plein de donnéer pour rien.

2- Lazy loading

Le lazy loading est une technique qui consiste à ne récupérer des données que quand on à réellement besoin.
Donc dans ton cas cela consisterait à remplir les champs de personne que quand tu as réellement besoin de l'afficher.

L'avantage est donc évident en terme de performance. En revanche c'est plus délicat à gérer puisqu'il faut pouvoir travailler avec des objets pas forcément complets puisque toutes les données ne sont pas forcément chargées.