Basic knowledge of PHP: classes and objects 5 static

Declaring class members or methods as static makes them accessible without needing an instantiation of the class. A member declaring as static can not be accessed with an instantiated class object (though a static method can).
Declaring static class variables and methods can Call them without instantiating class objects. Static classes cannot be called from class objects. (Static methods of classes are OK). //Pay attention to the first example, a static variable is called in a non-static method. The only difference is the use of self. Is it possible to use self????I don’t know???Need a test.
The static declaration must be after the visibility declaration. For compatibility with PHP4, if no visibility declaration is used, then the member or method will be treated as if it was declared as public.
The static declaration must be an explicit declaration. In order to be compatible with PHP4, if there is no explicitly declared object or method, it is regarded as declared as public.
Because static methods are callable without an instance of the object created, the pseudo variable $this is not available inside the method declared as static.
Because static methods do not need to instantiate a class object to call, the pseudo variable $this is in the static method is also unavailable in .
In fact static method calls are resolved at compile time. When using an explicit class name the method is already identified completely and no inheritance rules apply. If the call is done by self then self is translated to the current class, that is the class the code belongs to. Here also no inheritance rules apply.
Actually, static method calls are determined at compile time. (I don’t know how to translate this paragraph.??? I don’t understand???)
The translation I have been asking for for a long time is as follows:
---------------------- --------------------------
Actually, calls to static methods are resolved at compile time. When an explicit class name is used, the method is fully recognized without the need to apply inheritance rules. If called by itself, then itself is resolved to the current class, which is the class to which the code belongs. No inheritance rules apply here either.
But a new question:
There may not be inheritance here, why are inheritance rules mentioned? (???Don’t understand????)
Static properties cannot be accessed through the object using the arrow operator ->. Calling non-static methods statically generates an E_STRICT level warning.
Static members cannot be called by objects of the class through the arrow symbol ->. Static calls to a non-static method will result in an E_STRICT level warning.
Static member example:

Copy code The code is as follows:

class Foo
{
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;//Pay attention here!!!!
//return $my_static;//It will be written like this Can't go wrong. Need to test
}
}
class Bar extends Foo
{
public function fooStatic() {
parent::$my_static;//Pay attention here!!!!
}
}
print Foo:: $my_static . " n ";
$foo = new Foo();
print $foo->staticValue() . " n";
print $foo->my_static . " n"; // Undefined "Property" my_static
/ / $foo::my_static is not possible
print Bar::$my_static . " n";
$bar = new Bar();
print $bar->fooStatic() . " n";
Static method example:
class Foo {
public static function aStaticMethod() {
// // ...
}
}
Foo::aStaticMethod();

The above has introduced the basic knowledge of PHP: classes and objects 5 static, including aspects of content. I hope it will be helpful to friends who are interested in PHP tutorials.