Ok.
Voilà donc ce que je propose:
Voilà donc ce que je propose:
Code PHP :
<?php
/*objet*/
class Livre
{
private /*string*/ $titre;
private /*string*/ $texte;
public function __construct(/*string*/ $p_titre, /*string*/ $p_texte)
{
$this->titre = $p_titre;
$this->texte = $p_texte;
}
public /*string*/ function getTitre()
{
return ($this->titre);
}
}
/*conteneur*/
class ConteneurLivre
{
protected $livres;
public function __construct(/*array[Livre]*/ $p_livres=array())
{
$this->livres = Array();
foreach ($p_livres as $clivre)
$this->stack($clivre);
}
public function stack(/*Livre*/ $p_livre)
{
$this->livres[] = $p_livre;
}
public /*Livre*/ function unstack()
{
return (array_pop($this->livres));
}
public /*Livre*/ function getLivre(/*string*/ $p_titre)
{
foreach ($this->livres as $key=>$clivre)
{
if ($clivre->getTitre() == $p_titre)
{
unset($this->livres[$key]);
return ($clivre);
}
}
}
}
/*objet*/
class Bibliotheque
{
private /*ConteneurLivre*/ $livres;
public function __construct()
{
$this->livres = new ConteneurLivre();
}
public function addLivre(/*Livre*/ $p_livre)
{
$this->livres->stack(clone $p_livre);
}
public /*Livre*/ function getLivre(/*string*/ $p_titre)
{
return ($this->livres->getLivre($p_titre));
}
}
// Main
$myBook = new Livre('Lorem Ipsum', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit,...');
$bibliotheque = new Bibliotheque();
$conteneur = new ConteneurLivre();
$bibliotheque->addLivre($myBook);
$conteneur->stack($myBook);
$myOtherBook = $bibliotheque->getLivre('Lorem Ipsum');
$myOtherOtherBook = $conteneur->getLivre('Lorem Ipsum');
assert($myBook === $myOtherBook); //false
assert($myBook === $myOtherOtherBook); //true
assert($myOtherBook === $myOtherOtherBook); //false
?>Dans ce code, j'ai donc une classe Bibliothèque (objet), une "pseudo-classe" ConteneurLivre (conteneur) et une classe "Livre".
Si j'ajoute un livre au conteneur, je peux le récupérer et je suis certain qu'il s'agit du même livre. ConteneurLivre n'est donc, à mon sens, qu'un conteneur, et non un objet (puisque je peux garder la trace de l'objet entre l'appel à "get" et "set").
Si j'ajoute un livre à la bibliothèque, je peux en récupérer ensuite un autre, mais rien ne me garantis qu'il s'agira du même objet (Bibliothèque n'est pas un conteneur).
La première assertion est fausse, car Bibliothèque est un objet, qui donc ne garantie en rien la "consistance" (ou la tracabilité) des objets qu'on lui envoie (les Livre). En revanche, la seconde est vraie car elle utilise un Conteneur qui garantie cette traçabilité (mais qui, en contre partie, n'est pas un véritable "objet" à mon sens puisque je sais où et comment les données Livre circulent à l'intérieur du conteneur).
La troisième est fausse par déduction.
Maintenant, je veux changer la façon dont Bibliothèque stocke ses données:
Code PHP :
<?php
/*objet*/
class Livre
{
private /*string*/ $titre;
private /*string*/ $texte;
public function __construct(/*string*/ $p_titre, /*string*/ $p_texte)
{
$this->titre = $p_titre;
$this->texte = $p_texte;
}
public /*string*/ function getTitre()
{
return ($this->titre);
}
public /*string*/ function getContenu()
{
return ($this->texte);
}
}
/*objet*/
class Bibliotheque
{
private /*array[string]*/ $titres;
private /*array[string]*/ $textes;
public function __construct()
{
$this->titres = array();
$this->textes = array();
}
public function addLivre(/*Livre*/ $p_livre)
{
$this->titres[] = $p_livre->getTitre();
$this->textes[] = $p_livre->getContenu();
}
public /*Livre*/ function getLivre(/*string*/ $p_titre)
{
$index = array_search($p_titre, $this->titres);
unset($this->titres[$index]);
unset($this->textes[$index]);
return (new Livre($this->titres[$index], $this->textes[$index]));
}
}
// Main
$myBook = new Livre('Lorem Ipsum', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit,...');
$bibliotheque = new Bibliotheque();
$bibliotheque->addLivre($myBook);
$myOtherBook = $bibliotheque->getLivre('Lorem Ipsum');
assert($myBook === $myOtherBook); //false
?>