15

I've recently been working on some class files and I've noticed that the member variables had been set in a protected static mode like protected static $_someVar and accessed like static::$_someVar.

I understand the concept of visibility and that having something set as protected static will ensure the member variable can only be accessed in the super class or derived classes but can I access protected static variables only in static methods?

Thanks

2 Answers2

45

If I understand correctly, what you are referring to is called late-static bindings. If you have this:

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

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

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

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

If you change the self bit to:

echo static::$_foo;

Then do:

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

Because self refers to the class where $_foo was defined (A), while static references the class that called it at runtime (B).

And of course, yes you can access static protected members outside a static method (i.e.: object context), although visibility and scope still matters.

netcoder
  • 66,435
  • 19
  • 125
  • 142
7

Static variables exist on the class, rather than on instances of the class. You can access them from non-static methods, invoking them something like:

self::$_someVar

The reason this works is that self is a reference to the current class, rather than to the current instance (like $this).

By way of demonstration:

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

Output is barbar. However, if you try to access it directly:

echo A::$foo;

Then PHP will properly complain at you for trying to access a protected member.

Chris Heald
  • 61,439
  • 10
  • 123
  • 137
  • Okay so why would one use self over static? E.g. self::$foo or static::$foo –  Nov 25 '10 at 18:48
  • Oh yes when trying outside the class, but I'm talking about when accessing it within a class method. –  Nov 25 '10 at 18:50
  • If you define A->foo(), and it calls `self::$foo`, that'll return the static $foo defined in A. If you subclass A as a part of B, then invoke the inherited foo(), it'll use $foo from A, even if you defined it on B. Using static::$foo would use the $foo defined on B, if you had done so. – Chris Heald Nov 25 '10 at 18:51