Variable uit parent class halen

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.

Bedankt voor je reactie Wouter J. Maar dat is niet echt wat ik bedoel, ik wil namelijk niet de constructor uit de A class aanroepen maar de variable config via class B echoën. Het probleem is dat als class B de config-variable print dan is die leeg, terwijl de parent class (A) die wel al gevuld heeft met iets (test).

Dus als class B de variable config print dan zou je test moeten zien. Dit werkt alleen door een static variable te gebruiken, klopt dit?

Ruben, ik reageerde precies wat jij bedoelde. ;)

Want waar stel je die config property in? Juist ja, in de constructor van A. Wat gebeurd er dus als je in klasse B een constructor maakt? Dan wordt die van A niet meer aangeroepen. En als die van A niet meer aangeroepen wordt blijft de config property dus leeg. En wat gebeurd er als die leeg blijft? Dan zal de var dump in de constructor van B niks tonen.

Voorbeeldje misschien?
<?php
class A {
protected $config = array();

function __constructor() {
$this->config[] = 'test';
}
}

class B extends A {
function __constructor() {
// HIER EERST EVEN DE PARENT CONSTRUCTOR AANROEPEN
parent::__construct();
print_r($this->config);
}
}
?>

Oke bedankt. Ik had in het voorbeeld de constructor gebruikt. Maar in mijn 'echte' code heb ik het net in de constructor, maar in een gewone public function. En toch blijft hij leeg als ik hem via B aanroep.

EDIT: ik leg het even wat beter uit.

<?php
class A {
  protected $var;

  protected function set() {
    $this->var = 'boe';
  }

  protected function get() {
    return $this->var;
  }
}

class B extends A {
  protected function get() {
    return $this->var;
  }
}
?>

Als ik nu volgende code uitvoer zal ik niets terug krijgen:

<?php
$a = new A();
$b = new B();

$a->set();
$b->get();
?>

Als ik echter deze code uitvoer, zal het wel lukken:

<?php
$a = new A();
$b = new B();

$a->set();
$a->get();
?>

Dat is toch logisch? Extenden is 'uitbreiden'. die $a en $b zijn 2 totaal andere instances van een klasse, die kunnen niks van elkaar weten. Tenzij je de 1 in de ander injecteert:
<?php
class A {
protected $var;

public function set() {
$this->var = 'boe';
}

public function get() {
return $this->var;
}
}

class B
{
private $a;

public function setA(A $a)
{
$this->a = $a;
}

public function get()
{
return $this->a->get();
}
}

$a = new A();
$b = new B();
$b->seta($a);

$a->set();
$b->get(); // >> 'boe'
?>

Tevens kunnen die protecteds bij die methodes ook helemaal niet. Misschien goed om eens de basis te leren: http://phptuts.nl/view/45/

Bedankt voor je reactie!

Volgens mij kan je toch echt wel protecten function gebruiken?

Via jouw bron:

Voorbeelden van correcte method namen:
public function filterInput()
public function draw()
protected function _calculateTotal()
private function _countMessages()

Ja, maar dan kun je ze niet meer aanroepen op de manier zoals jij nu liet zien.

Ok bedankt. De manier die jij me aangeeft is niet echt hoe ik het wil. Ik zou het ook static kunnen doen, maar dat is af te raden? Ook vind ik static niet zo lekker werken.

Daarnaast vraag ik me af hoe ik dus eigenlijk het volgende kan doen:

<?php
class main {
  $db = object;

  function dbConnect() {
    $this->db = new mysqli($host, $user, $pass, $dbname);
  }
}

class user extends main {
  function logIn() {
    $this->db->query('SELECT * FROM users');
  }
}
?>

Dus eigenlijk heb ik een database class. In de main class wordt de databaseconnectie aangemaakt. Wat ik dan wil is dat de child user ook aan die database kan d.m.v. $this->db. Dit lukt me telkens niet. En ik wil niet $this->db doorsturen naar de user's constructor, dat ziet er echt niet 'proper' uit.

Singleton is ook niet goed? Kan je mij uitleggen waarom precies? Overal lees je verschillende verhalen.

Hoi Ruben.

Een user class extenden van een database class (jij noemt hem main) is niet logisch.
Een class administrator extenden van een user is wel logisch. een administrator is namelijk ook een user maar dan één met wat extra privileges.

Je zou het dus beter iets anders kunnen doen. (hoe daar zullen de meningen vast weer over uiteenlopen)
Maar toch een mogelijk idee.

<?php

class Database {
private $db;

function __constructor() {
$this->dbConnect();
}

public function dbConnect() {
$this->db = new mysqli($host, $user, $pass, $dbname);
}
}


class User {
private $db;

private $username;
// en zo nog meer

function __constructor($db, $userid) {
$this->db = $db;
// run query to retrieve user information with $userid
}

function logIn() {
$this->db->query('SELECT * FROM users');
// en zo nog meer
}
}

class Main {
private $db;

function __constructor() {
$this->db = new $db();

$user = new User($this->db, 1);

$user->logIn();
}
}

new Main();
?>