PHP：为什么我收到有关 static 属性的错误？

Question

http://codepad.viper-7.com/I0Zqoi

I don't understand what's wrong with this or how to fix it or why. Can someone who knows a little about programming please explain what's happening behind the scenes, like on the interpreter level? Also, how can I fix my problem, and why do I need to write my code in the way of the correction? Can you tell me, in human language, what is wrong with this and how to make it better? I guess my book isn't explaining well, and the code inside of it doesn't work. :/ Thank you.

class A 
{
  private $foo = 'bar';
  function read()
  {
      echo self::$foo;
  }
}

$a = new A();
a::read();

Strict Standards: Non-static method A::read() should not be called statically in /code/I0Zqoi on line 13

Fatal error: Access to undeclared static property: A::$foo in /code/I0Zqoi on line 8

The only workaround seems to be to add "static" in front of the method. Apparently, non-static methods cannot be accessed by static means (eg, class A{function read(){echo "whatever"};} cannot be accessed by a::read() because the -> operator is necessary). Also, static properties cannot be accessed by object code, even if they exist within a function (eg, class A{static $variable; function read(){echo $this->variable};} a->read(); won't work because the -> operator is being used to access a function that calls a static property.). By changing both the method and the property to static, the method can be accessed by static means. By changing both the method and property to non-static makes it so that either can be accessed with object instanciation. It doesn't make sense to me that the debugger is throwing errors because my book says that static properties can be called from non-static methods via object code calls to the non-static methods. So, is the debugger broken? Because I've tried every combination, and the code only seems to work if both the method and property are either static or non-static. :(((

Answer 1

The Strict Standards part is because a::read() is being called in a static context with :: . After declaring $a as a class instance of A , you should call the read() method on the variable using the -> operator:

// Proper non-static method call
$a = new A();
$a->read();

In the class definition, $foo is declared as a private property, but without the static keyword. It is then referred to in static context using the :: operator instead of the -> . The proper way to access it would beL

// Proper reference to non-static $foo
function read() {
  echo $this->foo;
}

Now what does static mean anyway? Static methods and properties refer to class methods and properties that are shared by all current and future class instances. If A::$foo had been declared as:

private static $foo;

then there would be only the one $foo for all of class A in your code. Changing $foo would affect all instances of class A , and $foo can be accessed without even creating an instance of the class (like new A(); )

Likewise, static methods can be called without creating an instance of the class because they do not modify class properties that are not also static.

// Static method call:
A::read();

To declare properties and methods as static , just add the static keyword:

// Property
private static $foo;

// Method
public static function foo() {}

EDIT for more examples :

class A
{
  // Private property (non-static)
  private $foo;

  // Public property (static)
  public static $bar = 12345;

  // Public (non-static) function to access private $foo
  public function getFoo() { return $this->foo; }

  // Public (non-static) function to set private $foo
  public function setFoo($newfoo) { $this->foo = $newfoo; }

  // Static function 
  public static function incrementBar() { self::$bar++; }
}

Now see it in action:

// We haven't created any class instances yet (with the 'new' operator)
// But we can access the static properties & functions:

echo A::$bar . " ";
// prints 12345

A::incrementBar();
echo A::$bar . "\n";
// prints 12346

// Now we'll start working with class instances.
// Create 2 instances of class A
$a = new A();
$a->setFoo(8888);
$b = new A();
$b->setFoo(9999);

// It's a violation of strict standards to call getFoo() statically
// And it's meaningless to do so, because $foo only exists inside a class instance!

// Can't do this... Issues a strict warning since we're calling non-static getFoo() statically
//echo A::getFoo();


// But we can call getFoo() on the class instances:
echo $a->getFoo() . " " . $b->getFoo() . "\n";
// Prints 8888 9999

// Remember $bar was 12346...
echo $a::$bar . " " . $b::$bar . "\n";
// Prints 12346 12346

// Now modify the static property $bar again
// This affects all class instances.
A::incrementBar();
echo $a::$bar . " " . $b::$bar . "\n";
// Prints 12347 12347

I stuffed this whole thing into the codepad as well: http://codepad.viper-7.com/tV6omK

The book you're reading must not be paying attention to strict standards. If a non-static function does not attempt to access/modify a non-static property, you can call it statically successfully, but it WILL issue a strict warning. If the non-static function does modify or access a non-static property with $this->property , it will be a fatal error. You can't do that.

In PHP's error_reporting , the setting of E_ALL for show all errors actually does not include strict warnings. That has to be done with E_ALL & E_STRICT .

Answer 2

:: is used to access a static attribute. If you want to access an object attribute then use -> .

$a->read();

...

echo $this->$foo;

Answer 3

Although the other answers are definitely correct, here's an answer to your concrete question:

It doesn't make sense to me that the debugger is throwing errors because my book says that static properties can be called from non-static methods via object code calls to the non-static methods. So, is the debugger broken? Because I've tried every combination, and the code only seems to work if both the method and property are either static or non-static. :(((

The author of your book was under the impression that not getting an error message is considered clean code. It's not. You shouldn't have a method that can be called both statically as well as dynamically, as the two simply differ too much. Dynamic calls are for objects, where static calls are for classes. If you have the opportunity, I would always try to go the dynamic way, as that yields less coupling in the application.

As to why "the debugger is throwing errors" (it's the interpreter throwing E_STRICT warnings, but hey;)): this behaviour has been changed in PHP five dot something. In PHP 4 you could call every method statically, even if it was a dynamic method. Possibly, your book is running behind on the facts.