guck dir das hier mal an:
ich meine, du brauchst einen rekursiven ansatz, um objektkomposition sauber verwenden zu können. das design pattern dazu heißt aggregat.
PHP-Code:
<?php
class Komponente {
var $_kinder = array();
var $_name;
var $_preis;
function Komponente($name,$preis = 0) {
$this -> _name = $name;
$this -> _preis = $preis;
}
function add(&$eineKomponente) {
$this -> _kinder[] = & $eineKomponente;
}
function getPreis() {
$summe = 0;
for($i=0,$m=count($this -> _kinder);$i<$m;$i++) {
$kind = & $this -> _kinder[$i];
/* @var $kind Komponente */
$summe += $kind -> getPreis();
}
return ($summe + $this -> _preis);
}
function getName() {
return $this -> _name;
}
}
// testing...
$tisch = new Komponente('tisch',80);
$stuhl = new Komponente('stuhl',30);
$wohnzimmer = new Komponente('wohnzimmer',0);
$wohnzimmer -> add($tisch);
$wohnzimmer -> add($stuhl);
$wohnung = new Komponente('wohnung',0);
$wohnung -> add($wohnzimmer);
$kueche = new Komponente('küche',0);
$herd = new Komponente('herd',800);
$kueche -> add($herd);
$wohnung -> add($kueche);
echo $wohnung -> getPreis();
?>
ich habe mal die kommentare weggelassen, damit das wichtige am code sichtbar wird.
du definierst dir eine oberklasse 'Komponente' oder 'Ware', die grundsätzlich erstmal sich selbst beschreibt.
dann kann eine komponente auch 'kinder' haben, die mit add() hinzugefügt werden.
dadurch, dass die kinder selbst ebenfalls komponenten sind, 'verhalten' sie sich alle gleich.
du kannst also beliebig komponenten verschachteln.
das schöne folgt aber erst, wenn du mit vererbung arbeitest.
PHP-Code:
<?php
class Tisch extends Komponente {
function Tisch() {
$this -> _name = 'tisch';
$this -> _preis = 80;
}
}
class Stuhl extends Komponente {
function Stuhl() {
$this -> _name = 'stuhl';
$this -> _preis = 30;
}
}
class Kueche extends Komponente {
function Kueche() {
$this -> _name = 'kueche';
$this -> _preis = 0;
}
}
class Wohnzimmer extends Komponente {
function Wohnzimmer() {
$this -> _name = 'wohnzimmer';
$this -> _preis = 200; // grundausstattung
$stuhl = new Stuhl();
for($i=0;$i<6;$i++) { // einfach mal annehmen, dass das Wohnzimmer standardmäßig 6 stühle hat.
$this -> add($stuhl);
}
$tisch = new Tisch();
$this -> add($tisch);
}
}
//// usage:
$wohnung = new Komponente('wohnung',0);
$wohnzimmer = new Wohnzimmer();
$kueche = new Kueche();
$stuhl = new Stuhl();
$kueche -> add($stuhl);
$wohnung -> add($wohnzimmer);
$wohnung -> add($kueche);
echo $wohnung -> getPreis();
?>
... wie du siehst, kannst du damit dann beliebig unterklassen bauen, die ihr komplettes sonstiges verhalten verändern - sie könnten theoretisch sogar ihren preis anders berechnen etc...
dadurch aber, dass sie alle Komponenten sind, kannst du beliebig damit rechnen.
das einzige was du nicht machen darfst, sind ring-referenzen:
also niemals:
Code:
$wohnung = new Wohnung('hallo',0);
$wohnung -> add($wohnung);
sonst gibt's 'ne wunderbare endlosschleife
grüße
axo