How to override a static property of a parent object and let the parent object access the new value in PHP?

Question

This is what I have: All objects that can be persisted on the database extend the DatabaseObject abstract class, which has all the logic code to actually watch for attribute changes and run the databas queries.

I'm using two static variables to define object-specific details. I define them generically in the base class, and then supposedly I overwrite them in the actual database objects.

The problem is: When the code in the parent class is actually executed, it uses the old parent value instead of the current object value.

Here's the code for the base class:

abstract class DatabaseObject {

    public $id;

    private static $databaseTable = NULL;
    private static $databaseFields = array();

    private $data = array();
    private $changedFields = array();

    public function IDatabaseObject($id) {
    $this->id = $id;
    $this->data = Database::GetSingle(self::$databaseTable, $id);

    Utils::copyToObject($this, $this->data, self::$databaseFields);
    }

    public static function Load($id) {
    return new self($userID);
    }

    public static function Create($data) {

    $id = Database::Insert(self::$databaseTable, $data);

    return new self($id);
    }

    public function Save() {
    $data = Utils::copyFromObject($this, $this->changedFields);

    Database::Update(self::$databaseTable, $data, $this->id);

    }

    public function __constructor() {
    // We do this to allow __get and __set to be called on public vars
    foreach(self::$databaseFields as $field) {
        unset($this->$field);
    }
    }

    public function __get($variableName) {
    return $this->$variableName;
    }

    public function __set($variableName, $variableValue) {
    // We only want to update what has been changed
    if(!in_array($variableName, $this->changedFields) && in_array($variableName, self::$databaseFields)) {
        array_push($this->changedFields, $variableName);
    }

    $this->$variableName = $variableValue;
    }
}

And here's the code for one of the objects extending the base class above:

class Client extends DatabaseObject {

    public static $databaseTable = "clients";
    public static $databaseFields = array("name","contactName","primaryUserID","email","is_active","rg","cpf","cnpj","ie","addrType","addrName","addrNumber","addrComplement","addrPostalCode","addrNeighborhood","addrCity","addrState","addrCountry","phoneLandline","phoneFax","phoneMobile");

    public $name;
    public $contactName;

    public $primaryUserID;
    public $email;

    public $is_active;

    public $rg;
    public $cpf;
    public $cnpj;
    public $ie;

    public $addrType;
    public $addrName;
    public $addrNumber;
    public $addrComplement;
    public $addrPostalCode;
    public $addrNeighborhood;
    public $addrCity;
    public $addrState;
    public $addrCountry;

    public $phoneLandline;
    public $phoneFax;
    public $phoneMobile;

    public static function Load($id) {
 return new Client($id);
    }

}

What am I doing wrong here? Is there another way I can achieve the same result?

A brief addendum: I declare the attributes in the class body mainly to let it be seen by the NetBeans' auto-complete feature.

Answer 1

You are looking for Late Static Binding.

So you need to use:

static::$databaseTable

instead of

self::$databaseTable

This feature is available as of PHP 5.3. Simulating this in PHP 5.2 is very hard, because of two reasons: get_called_class is available only since PHP 5.3, too. Therefore it must be simulated, too, using debug_backtrace. The second problem is, that if you have the called class, you still may not use $calledClass::$property because this is a PHP 5.3 feature, too. Here you need to use eval or Reflection. So I do hope that you have PHP 5.3 ;)