Question

我有一个基类，我需要在子类中引用的类上调用函数。

很容易，

class base_class {

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

class extended_class extends base_class{

    protected $reference;

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

现在这显然很好，

但是，当我调试时，我并不关心$this->reference

的价值

但是，$this->reference引用的对象是巨大的！

所以，当我print_r($instanceOfExtendedClass)时，我得到了该对象的打印件。

现在，每个扩展base_class的类的引用都不同。

我想要做的只是将reference设置为extended_class类的静态属性。

但是，然后将doSomethingWithReference更改为self::$reference会引发未定义的变量错误。

相反，在base_class中设置静态变量并从extended_class修改它不起作用，因为它更改了从该类扩展的所有内容的变量。

有没有办法做到这一点，所以我没有打印出$this->reference？

Answer 1

因为您使用的是PHP 5.3，所以可以使用late static binding在运行时解析对正确类的静态调用。

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;
    }

}

大胖提醒：extended_class::$reference实例的所有之间将共享extended_class。如果这不是你想要的，那就不行了。

您似乎真的担心内存或资源使用。在PHP中，所有对象都通过引用传递。这意味着将对象作为参数传递或创建它的副本等不会消耗额外的内存。如果你需要在许多其他对象中引用一个对象，那么不会占用额外的内存。

如果我有extended_class和另一个相同的类（比如extended_class1），他们也会共享引用吗？或者所有extended_class'实例是否共享一个引用，而所有extended_class1'实例将共享另一个（理想情况）？

看起来共享基于静态变量的定义位置。两个例子，都来自PHP交互式提示：

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

在这种情况下，因为引用存在于基类中，所以每个人都看到相同的引用。我认为这有点道理。

当我们在每个子类中声明引用时会发生什么...大部分时间？

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

因为3继承自1而没有声明它自己的静态属性，所以它继承了1。当我们将3设置为Shared（3）时，它覆盖了1的现有Shared（1）。

结论：要使其工作，需要在每个需要单个唯一引用的类中声明属性。请注意，此代码自5.4.x起有效。

Answer 2

为父级提供访问子级静态成员的方法：

<?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);
?>

从父类访问子类静态变量？

2 个答案: