Door
Ruben Portier
op 10-02-2013 17:09
gewijzigd op 10-02-2013 17:09
1.942 views
Beste
Ik heb wat lopen rond zoeken op internet maar kan helaas geen goed werkende oplossing vinden. Ik heb namelijk twee classes.
<?php
class A {
protected $config = array();
function __constructor() {
$this->config[] = 'test';
}
}
class B extends A {
function __constructor() {
print_r($this->config);
}
}
?>
Het probleem is nu dat de constructor van class B een lege array terug geeft terwijl de parent wel degelijk iets in de config array geplaatst heeft.
Iemand een idee hoe ik dit kan oplossen? Of moet ik hierbij verplicht static gaan gebruiken?
Bedankt, ik zal even uitleggen waarom ik het op die manier wil. Ik ben namelijk een eigen framework aan het maken gebaseerd op de model-view-controller methode. Ik heb een system class die als basis van mijn framework dient. Dan heb ik andere classes die daaronder vallen: controller, model, database...
De controller class extend op de system class, zelfde voor model, database enz. De controller class dient bv. om controllers mee te laden, de model class om models te laden, de database dient dan weer om een database connectie te maken.
Mijn vraag is nu, hoe kan een controller die geladen wordt door de controller class (de controller die geladen wordt extend op de controller class, die dan weer extend op de system class) de database class gaan gebruiken (die extend op de system class).
Ik heb al naar dergelijke frameworks gekeken en sommigen gebruiken Singleton. Ik weet niet of dit zo'n goed idee is. Het zou toch ook anders moeten kunnen?
Ruben, naar mijn mening [size=xsmall](maar dit is het eerste topic dat ik van je lees)[/size] denk jij nu nog veel te makkelijk over OO. Al die extends zijn namelijk compleet verkeerd. Ik raad je aan eerst eens goed naar OO principes te kijken, en dan niet alleen naar OO syntax tutorials, en dan kun je over een half jaar misschien nog eens nadenken over het zelf maken van een framework.
Ik zal je zeker geen ongelijk geven. Maar het is net om beter te worden in OO dat ik een framework wil maken. Niet meteen een framework die ik ook echt wil gaan gebruiken. Ik heb er namelijk in 4 weken tijd al 5 verwijderd. Telkens begin ik opnieuw omdat ik het op een andere manier wil gaan bouwen.
Wat ik wel zou kunnen doen is telkens waar ik de database nodig heb het volgende commando uit te voeren:
<?php
$this->load->database();
?>
Maar hoe kan ik dan maken dat je de database kan aanroepen via $this->db? Dus ik laad hem met een load-functie die in de parent class staat. Die maakt dan een nieuw database-object aan op $this->db. Maar kan de child dan ook aan die database komen? Of zal die ook leeg zijn?
Telkens begin ik opnieuw omdat ik het op een andere manier wil gaan bouwen.
En precies om deze rede raad ik je dus aan om eerst eens goede OO denk tutorials te lezen. Je begint telkens opnieuw, omdat iets mooiers in gedachte had. Wat je bij OO juist doet is dat je de eerste 2 maanden je computer niet aanzet en je alleen je project gaat uitschrijven, totdat je echt alles hebt zoals jij het wilt.
En als je OO wilt leren zou ik zeker niet met een framework beginnen. Werelds grootste OO en PHP experts doen er alsnog met 100 man een jaar over om een framework te onderhouden en enkele kleine nieuwe dingen eraan toe te voegen. Frameworks zijn de meest ingewikkelde systemen die je in PHP ooit gaat maken. Frameworks kun je alleen beginnen als je OO principes en design pattern volledig hebt begrepen en jaren ervaring er mee hebt.
Er zijn hier al meerdere forumleden aan frameworks begonnen en het is leuk dat ze het doen, maar daar blijft het ook wel bij. Ze hebben deze projecten al meerdere malen opnieuw opgestart en of ze ooit hun framework afkrijgen stel ik ter discussie.
In PHP wordt de constructor overriden. Je krijgt nu dus alleen de constructor van B en niet meer die van A. Gebruik parent::__construct() om de parent constructor aan te roepen.
Niet alleen in PHP hoor wouter :)
@TS
Volgens mij wil jij het volgende
<?php
class A {
private $name;
public function __construct($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
}
?
en dan de child klasse aanmaken
<?php
class B extends A {
public function __construct($name) {
parent::__construct($name);
}
}
?>
Wat je dan doet om via class B de methode aan te roepen die je in de parent class hebt staan is
<?php
$b = new B('Batman');
echo 'Ik heet ' . $b->getName();
?>
Als je in class B een nieuwe constructor zou maken ( zonder parent::__construct();) zou deze de constructor van A overriden
