2010-11-25 26 views
10

Recientemente he estado trabajando en algunos archivos de clase y me he dado cuenta de que las variables miembro se habían establecido en un modo estático protegido como static $ _someVar protegido y se accedía como static :: $ _ someVar.Variables miembro estáticas protegidas

Entiendo el concepto de visibilidad y que tener algo establecido como estático protegido garantizará que solo se pueda acceder a la variable miembro en la superclase o clases derivadas, pero ¿puedo acceder a variables estáticas protegidas solo en métodos estáticos?

Gracias

Respuesta

33

Si entiendo correctamente, a lo que se refiere se llama late-static bindings. Si usted tiene esto:

class A { 
    static protected $_foo = 'bar'; 

    static public function test() { 
     echo self::$_foo; 
    } 
} 

class B extends A { 
    static protected $_foo = 'baz'; 
} 

B::test(); // outputs 'bar' 

Si cambia el self poco para:

echo static::$_foo; 

Luego hacer:

B::test(); // outputs 'baz' 

Debido self se refiere a la clase en la que se definió $_foo (A) , mientras que static hace referencia a la clase que lo llamó en el tiempo de ejecución (B).

Y, por supuesto, sí, puede acceder a los miembros protegidos estáticos fuera de un método estático (es decir, contexto del objeto), aunque la visibilidad y el alcance siguen siendo importantes.

+2

Creo que la clase B debería ser "clase B extiende A" en este ejemplo. –

+0

@Nathan: Buena llamada (incluso semanas más tarde). Fijo. ¡Gracias! – netcoder

6

variables estáticas existen en la clase, más que en casos de la clase. Se puede acceder a ellos desde los métodos no estáticos, ellos invocando algo como:

self::$_someVar 

La razón por la que esto funciona es que self es una referencia a la clase actual, en lugar de a la instancia actual (como $this).

A modo de demostración:

<? 
class A { 
    protected static $foo = "bar"; 

    public function bar() { 
    echo self::$foo; 
    } 
} 

class B extends A { } 

$a = new A(); 
$a->bar(); 

$b = new B(); 
$b->bar(); 
?> 

salida es barbar. Sin embargo, si se intenta acceder a él directamente:

echo A::$foo; 

PHP Luego se quejan correctamente contigo por intentar acceder a un miembro protegido.

+0

Bien, entonces, ¿por qué uno usaría auto sobre la estática? P.ej. self :: $ foo o static :: $ foo –

+0

Oh sí cuando lo intento fuera de la clase, pero me refiero a cuando se accede dentro de un método de clase. –

+0

Si defines A-> foo(), y llama a 'self :: $ foo', eso devolverá el $ foo estático definido en A. Si subclases A como parte de B, entonces invocas el foo heredado (), usará $ foo de A, incluso si lo definió en B. Usar static :: $ foo usaría el $ foo definido en B, si lo hubiera hecho. –