Discussion :

[bressan]

Bonjour,

J'aimerai votre avis sur deux classes A et B. Ces classes correspondent à deux tables de relation 0,n. En fait, ce que j'aimerai savoir c'est si la manière de faire est correcte. Je sais que c'est un peu floue comme question mais je ne sais pas trop comment le dire plus précisément.
J'aurai une seconde interrogation ensuite : comment dans ma classe A intégrer une liste (tableau) d'objet B ? Le mieux est-il de creer une autre classe du style ListeB renvoyant un tableau de B ou de créer un tableau de B directement dans la classe A ? Ou les deux méthodes sont-elles correctes ?
Et si je garde mon code tel quel, dans les deux cas, la dernière ligne de la méthode getB () ne va-t-elle pas donner une boucle infinie ?
Merci d'avance et n'hésitez pas à me faire préciser quoique ce soit.

Voici le code incriminé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
<?php
class A
{
	private $connexion;
	private $idA;
	private $nomA;
 
	private $type;
 
	function __construct ($idA = 0)
	{
		$this->connexion	=	new Connexion ();
		$this->idA		=	$idA;
 
		if (is_numeric ($this->idA) && $this->idA != 0)
		{
			$this->getA ($this->idA);
		}
	}
 
	function __toString ()
	{
		return "$this->nomA ($this->idA)";
	}
 
	function toString ()
	{
		return "$this->nomA ($this->idA) ($this->type)";
	}
 
	private function getA ($idA)
	{
		$tab		=	$this->connexion->interroge ("SELECT * FROM A WHERE id = $this->idA");
 
		$this->idA =	$tab[0]["id"];
		$this->nomA =	$tab[0]["nom"];
		$this->type =	$tab[0]["type"];
	}
 
	// Getter and setter
}
 
class B	extends A
{
	private $connexion;
	private $idB;
	private $nomB;
 
	private $min;
	private $max;
 
	function __construct ($idB)
	{
		$this->connexion	=	new Connexion			();
		$this->idB		=	$idB;
 
		if (is_numeric ($this->idB) && $this->idB != 0)
		{
			$this->getB ($this->idB);
		}
	}
 
	function __toString ()
	{
		return "$this->nomB ($this->idB)";
	}
 
	function toString ()
	{
		return "$this->nomB ($this->idB) ($this->min - $this->max)";
	}
 
	private function getB ($id)
	{
		$tab		=	$this->connexion->interroge ("SELECT * FROM B WHERE id = $this->idB");
 
		$this->idB	=	$tab[0]["id"];
		$this->nomB	=	$tab[0]["nom"];
 
		$this->min	=	$tab[0]["min"];
		$this->max	=	$tab[0]["max"];
 
		parent::__construct	($tab[0]["idA"]);
	}
 
	// Getter and setter
}
?>

[Celira]

Je pense que ce serait plus clair si on avait la structure de ta base de données. Et donner des noms qui veulent dire quelque chose à tes tables et tes objets pourrait également être une bonne idée.

Au passage, attention avec la notion d'héritage. Faire hériter une classe d'une autre c'est dire que la classe Fille est la même chose que la classe mère avec des attributs et des méthodes en plus et/ou redéfinis : par exemple, une classe Chien qui hérite de la classe Animal ou une classe Voiture hérite d'une classe Véhicule. Je ne suis pas sure que ce soit réellement ton cas....

[bressan]

Déjà merci d'avoir répondu.
En fait, je dois refaire quleque chose d'existant et je voudrai connaitre la meilleur manière de faire les choses.
D'après ta réponse, je pense que tu as raison concernant mon cas précis. Mes classes concernent des gîtes contenant des chambres. Et donc un gîte et une chambre ne sont pas la même chose. J'imagine donc que mon objet gite devra contenir une variable tableau de chambre ???
Je me permets du coup d'exposer mon problème. J'ai des centaines d'informations sur chaque gîte : chambres (descriptions, disponibilités), facturations, coordonnées bancaires, localisations, infos sur la région touristique ... Je pensai donc faire pour chaque une classe qui hériterait de Gite, car Gite va devenir une classe plus qu'énorme et je crains que ce soit extrêmement lourd lorsque je vais avoir une liste de Gite.
De plus, je dois pouvoir, par exemple, fournir une liste de chambre disponible dans telle région à telle période. Puisque la disponibilité est définie au niveau de la chambre (libre ou occupée), je pensais qu'il était plus judicieux d'avoir une classe Chambre à part entière.
Voilà donc mon soucis.

[bressan]

En fait, j'imagine que je dois seulement faire deux classes, Gite et Chambre. La classe Gite contenant une variable contenant un tableau de Chambre.
Ensuite, si effectivement ma classe Gite devient très importante, est-il judicieux de ne pas remplir toutes les variables (comme les coordonnées bancaires, ...) systématiquement mais en fonction d'un paramètre ou de faire plusieurs classes Gite (par exemple une classe Gite sommaire, une classe Gite avec le tableau de Chambre et une classe Gite complète) ???
Ou troisième possibilité, je suis à côté de la plaque et dans ce cas je veux bien que vous m'aiguilliez dans la bonne direction.

[mathieu44800]

Bonjour,

Pour ma part, je pense que tu es dans la bonne direction avec tes classes.

Une Classe Gite avec toutes les informations avec une relation 1,n de chambres (relation d'appartenance).

Ce qui se traduirait par une collection de chambres dans ta classe Gite.

Après tu pourras enrichir tes classes de méthodes qui te permettront de stocker ou d'accéder a leurs données.

Par contre, petit conseil : sépare mieux tes couches (accès données & méthodes métier)...

A+

Mathieu

[bressan]

Merci de ta réponse.

Ce que tu me conseilles, est-ce quelque chose dans ce goût là (je n'ai mis que l'essentiel pour comprendre l'idée que je me suis fait du conseil que tu m'as donné) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
class Gite
{
	private $idGite		=	"";
	private $nomGite	=	"";
 
	private $chambre	=	array ();
 
	function __construct ($idGite = "", $nomGite = "")
	{
		$this->idGite	=	$idGite;
		$this->nomGite	=	$nomGite;
		$this->chambre	=	new GestionChambre ($idGite);
	}
}
 
class GestionGite
{
	private $connexion;
	private $gite;
 
	function __construct ($idGite)
	{
		$this->connexion	=	new Connexion ();
		$tab	=	$this->connexion->interroge ("Requête SQL idGite = $idGite");
 
		$this->gite	=	new Gite ($tab[0]["id"], $tab[0]["nom"]);
	}
 
	public function getGite ()
	{
		return $this->gite;
	}
}
 
class Chambre
{
	private $idChambre	=	"";
	private $nomChambre	=	"";
 
	function __construct ($idChambre = "", $nomChambre = "")
	{
		$this->idChambre	=	$idChambre;
		$this->nomChambre	=	$nomChambre;
	}
}
 
class GestionChambre
{
	private $connexion;
	private $chambre	=	array ();
 
	function __construct ($idGite)
	{
		$this->connexion	=	new Connexion ();
		$tab	=	$this->connexion->interroge ("Requête SQL idGite = $idGite");
		foreach ($tab as $line)
		{
			$this->chambre[]	=	new Chambre ($line["id"], $line["nom"]);
		}
	}
 
	public function getChambre ()
	{
		return $this->chambre;
	}
}

J'ai vu dans des tutos qu'il est d'usage de faire des classes Factory (dans mon cas FactoryChambre) qui représentent des listes/tableaux de la class métier concernée. Dans mon cas, serait-ce utile ? D'ailleurs, je ne comprends pas bien l'utilité puisque si je créée un tableau de Gite j'aurai exactement la même chose. non ?

[mathieu44800]

Bonjour,

Je ne vois pas trop l'interêt de deux classes par Entité.

En effet, pourquoi ne pas regrouper tes classes comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
42
43
 
class Gite
{
	private $idGite		=	null;
	private $nomGite	        =	null;
	private $connexion       =      null;
 
	private $chambres	=	array ();
 
        private function setConnexion()
        {
           if (is_null($this->connexion))
           {
              $this->connexion	=  new Connexion ();
           }
        }
 
 
	public function __construct ($idGite)
	{
		$this->setConnexion();
		$tab	=	$this->connexion->interroge ("Requête SQL idGite = $idGite");
 
		$this->idGite	=	$tab[0]["id"];
		$this->nomGite	=	$tab[0]["nom"];
 
                // D'autres infos...
	}
 
        public function getChambres()
        {
               $this->setConnexion();
	       $tab	=	$this->connexion->interroge ("Requête SQL idGite = $idGite");
	       foreach ($tab as $line)
	       {
                    // On peux même se demander si un objet chambre est nécessaire dans ton cas
		    $chambre = new Chambre();
                    $chambre->set('id', $line["id"]);	
                    $chambre->set('nom', $line["nom"]);
                    $this->chambres[]	=   $chambre; // array_push ??
	        }
        }
}

Pour ta classe Chambre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
class Chambre
{
	private $idChambre	=	null;
	private $nomChambre	=	null;
 
	 public function __set($attr, $value)
         {
              if (! isset($this->$attr))
              {
                  throw new Exception('Unknow attribute '.$attr);
              }
 
              $this->$attr = $value;
         }
}

Après ce n'est qu'une méthode comme une autre.

Par contre, tu vas certainement avoir besoin de manipuler une collection de gites.

Pourquoi pas un Manager...

Cordialement,

Mathieu

[bressan]

Merci beaucoup pour l'aide apportée.
Je vais regarder cette histoire de Manager qui, s'il est comme les autres, doit être un bon conseil.