Static variables in PHP5.3

1. Static variables
1. Static variables are variables that only exist in the scope. However, after the function execution is completed, the value of this variable will not be lost. That is to say, the next time this function is called, the variable will still be Remember the original value.
2. It is illegal to assign the calculated result of an expression to a static variable. An expression refers to any statement whose value will change. For example, (1+1), $variable, and anyfunc() are all expressions.
3. You may think that defining static variables does not seem very useful, because the same result can be easily obtained using global variables. However, global variables can be accessed by all functions, so if two or more functions that are supposed to be independent use variables with the same name, conflicts will occur; and, compared to introducing global variables, using static variables does not require more Lots of syntax. Therefore, when only one function needs to access a certain variable, we should prefer to use static variables instead of global variables.

2. The use of static elements in classes
4. In classes, the static keyword has two main uses, one is used to define static members, and the other is used to define static methods.
5. A static member is a class variable, which can be regarded as belonging to the entire class rather than to an instance of the class. Different from general instance variables, static members only retain one variable value, and this variable value is valid for all instances, that is, all instances share this member.
6.$this only represents the instance of the current class, self:: represents the class itself (add $ after)
7. Scope limiting operator::
Through the scope limiting operator, we can use two system-defined functions Domains: self and parent. In addition, php5.3 also provides static scope. self represents the scope of the current class, but unlike $this, it does not represent a specific instance of the class. This operator cannot be used in code outside the class, and it does not recognize its position in the inheritance tree hierarchy. That is to say, when using self scope in an extended class, self can call methods declared in the base class, but it always calls methods that have been overridden in the extended class. (Equivalent to method coverage in java, use parent to explicitly call the parent class method)

Rewrite the static variables of the parent class and define the same static variables in the subclass

Php code

class aaa

{

function bbb(){

echo 'Use a double colon:: to call a class method!';

}

}

//Call 1:

$a = new aaa();

$a->bbb();

//Call 2:

aaa::bbb();

?> ;

The results obtained by the two methods are the same.

I don’t understand why the ordinary method bbb can also be called directly with the class name::. This seems to be different from that in java

Java code

Test.java

class Test{

//Common method

public void eat() {

System.out.println("no-static!");

}

//Static method

public static void show(){

System.out.println("static!") ;

}

//main method

public static void main(String args[]){

Test obj=new Test();

obj.eat( ); //Output no- static!

obj.show();//The method belongs to the class, and instances of the class can of course be accessed, but editors such as eclipse will have a yellow prompt suggesting calling it directly with the class name

                                                                                                                     from the type Test should be accessed in a static way)

Test.show();//Output static

                                                                                                                                                                             Test. ) php is bearable. . .

}

}

Personal understanding: As long as $this->xx does not appear in the ordinary method being called ($this only represents an instance of the current class), the ordinary method can also be considered to belong directly to the class, so it can be called directly with the class name, and Unlike methods in Java, which must be declared static before they can be called directly using the class name (php6 has made several changes in the operation of static methods. First, when accessing non-static methods, the :: operator is no longer used! This method requires It was killed. . . )

Help the parent class to call the method of the subclass
The static:: scope proposed in php5.3 makes us no longer need to use self:: and parent::. When you want to point to the final implementation class, you can use static::. This qualifier will calculate the members of the last class in the inheritance hierarchy immediately before the code is executed. This process is called delayed binding. I don't seem to see the use. Can't I just create a new object of the final implementation class directly in the parent class and then call it? But if you don't know what the final class is called and what effect the overridden method achieves, this seems to be useful. static::scope can also be applied to static methods, so that subclass methods can be called statically from the parent class.