Accéder aux variables statiques de la classe enfant à partir de la classe parent?

J'ai une classe de base que j'ai besoin d'appeler des fonctions sur une classe qui est référencé dans la classe enfant.

Assez facile,

class base_class {

    public function doSomethingWithReference(){
        $this->reference->doSomething();
    }
}

class extended_class extends base_class{

    protected $reference;

    public function __construct($ref){
        $this->reference = $ref;
    }
}

Maintenant cela fonctionne bien évidemment,

Mais, quand je suis débogage je ne se soucient pas de la valeur de $this->reference

Mais, l'objet qui $this->reference se réfère est énorme!

donc, quand je ne print_r($instanceOfExtendedClass) - je obtenir de l'impression de cet objet.

Maintenant la référence est différente pour chaque classe qui étend la classe base_class.

Ce que je voulais faire, c'était de définir reference comme une propriété statique sur le extended_class classe.

Mais, ensuite de changer doSomethingWithReference être self::$reference jette un undefined variable d'erreur.

Et, inversement, le réglage de la variable statique dans base_class et de la modifier à partir de extended_class ne fonctionne pas comme il modifie la variable pour l'ensemble de tout ce qui s'étend à partir de cette classe.

Est-il possible de faire cela, donc je n'ai pas l'impression de $this->reference?

source d'informationauteur Hailwood

Parce que vous êtes à l'aide de PHP 5.3, vous pouvez utiliser late static binding pour résoudre l'appel statique de la classe à droite au moment de l'exécution.

class base_class {

    public function doSomethingWithReference(){
        static::$reference->doSomething();
    }

}

class extended_class extends base_class{

    protected static $reference;

    public function __construct($ref){
        static::$reference = $ref;
    }

}

Big fat rappel: Que l'on extended_class::$reference est destiné à être partagé entre tous de la extended_class instances. Si ce n'est pas ce que vous entendez, ce n'est pas d'aller travailler.

Vous semblent effectivement être inquiet au sujet de la mémoire ou de l'utilisation des ressources. En PHP, tous les objets sont passés par référence. Cela signifie que le passage d'un objet comme argument, ou la création d'une copie de celui-ci, etc, ne consomme pas de mémoire supplémentaire. Si vous avez besoin de faire référence à un objet d'un certain nombre d'autres objets, donc va pas consomment de la mémoire supplémentaire.

Si j'avais extended_class et un autre identique classe (disons extended_class1) seraient-ils partager la référence? ou serait-tous extended_class instances de partager une référence, alors que tous les extended_class1' les instances part de l'autre (cas idéal)?

Il ressemble le partage est basé sur l'endroit où la variable statique est définie. Deux exemples, à la fois de la PHP invite interactive:

php > class Shared { public $me; public function __construct($me) { $this->me = $me; } }
php > class Base { protected static $ref; public function foo() { echo static::$ref->me, "\n"; } }
php > class Inherit_1 extends Base { public function __construct($ref) { static::$ref = $ref; } }
php > class Inherit_2 extends Base { public function __construct($ref) { static::$ref = $ref; } }
php > class Inherit_3 extends Inherit_1 {}
php > $shared_1 = new Shared(1)
php > ;
php > $shared_2 = new Shared(2);
php > $shared_3 = new Shared(3);
php >
php > $in_1 = new Inherit_1($shared_1);
php > $in_2 = new Inherit_2($shared_2);
php > $in_3 = new Inherit_3($shared_3);
php >
php > $in_1->foo();
3
php > $in_2->foo();
3
php > $in_3->foo();
3

Dans ce cas, parce que la référence à la vie dans la classe de base, tout le monde voit la même. Je suppose que cela fait une sorte de sens.

Ce qui se passe lorsque nous déclarons que la référence à chaque enfant de la classe.. la plupart du temps?

php > class Shared { public $me; public function __construct($me) { $this->me = $me; } }
php > class Base { public function foo() { echo static::$ref->me, "\n"; } }
php > class Inherit_1 extends Base { protected static $ref; public function __construct($ref) { static::$ref = $ref; } }
php > class Inherit_2 extends Base { protected static $ref; public function __construct($ref) { static::$ref = $ref; } }
php > class Inherit_3 extends Inherit_1 {}
php > class Inherit_4 extends Inherit_1 { protected static $ref; }
php > $shared_1 = new Shared(1);
php > $shared_2 = new Shared(2);
php > $shared_3 = new Shared(3);
php > $shared_4 = new Shared(4);
php > $in_1 = new Inherit_1($shared_1);
php > $in_2 = new Inherit_2($shared_2);
php > $in_3 = new Inherit_3($shared_3);
php > $in_4 = new Inherit_4($shared_4);
php > $in_1->foo();
3
php > $in_2->foo();
2
php > $in_3->foo();
3
php > $in_4->foo();
4

Car 3 héritée de 1, sans le déclarer propre propriété statique, il a hérité d'1. Lorsque nous avons mis 3 est Partagée(3), il a remplacé 1 est Partagé existant(1).

Conclusion: Pour que cela fonctionne, la propriété doit être déclaré dans chaque classe qui a besoin de la seule et unique référence. Notez que ce code est valable à compter de 5.4.x.

Fournir un moyen pour les parents de l'accès de l'enfant membre statique:

<?php
abstract class base_class {
abstract protected function reference();
//If you want to be able to instanciate base class directly, use the following 2 lines in place of the previous 2 lines:
//class base_class {
//protected function reference() {}
public function doSomethingWithReference(){
$this->reference()->doSomething();
}
}
class extended_class extends base_class{
protected static $reference;
public function __construct($ref){
self::$reference = $ref;
}
protected function reference(){
return self::$reference;
}
}
class ref {
public function doSomething(){
echo __METHOD__;
}
}
$ref = new ref();
$ec = new extended_class($ref);
$ec->doSomethingWithReference();
print_r($ec);
?>

Vous devez vous connecter pour publier un commentaire.