Analysis of the difference between static classes and static variables in PHP

Analysis of the difference between static classes and static variables in PHP_PHP Tutorial

WBOY

Release： 2016-07-13 10:09:39

Original

952 people have browsed it

Analysis of the difference between the usage of static classes and static variables in PHP

Static is to define a static object or static variable. We have finished reading about the characteristics of variables or class methods defined by static You will see the result after the relevant examples in this article.

1. Create object $object = new Class(), and then use "->" to call: $object->attribute/function, provided that the variable/method is accessible.

2. Directly call class methods/variables: class::attribute/function, whether it is static or non-static, but there are prerequisites.

A. If it is a variable, the variable needs to be accessible.

B. If it is a method, in addition to the method being accessible, it also needs to meet the requirements.

① If it is a static method, there are no special conditions.

② If it is a non-static method, you need to change the method so that $this is not used, that is, non-static variables/methods are not called. Of course, there is no problem in calling static variables/methods.

Then let’s look at the difference between using $object->… and using class::…:

1. Using $object->…, you need to execute the constructor to create the object.

2. Use class::... to call static methods/variables without executing the constructor to create objects.

3. Use class::... to call non-static methods/variables, and there is no need to execute the constructor to create objects.

Then the strange thing comes out. Since 2 and 3 are the same, what is the point of the existence of static methods/variables?

Static: Declaring class members or methods as static means they can be accessed directly without instantiating the class. Static members cannot be accessed through an object (except for static methods). Static members belong to the class and do not belong to any object instance. , but all object instances of the class can be shared.

Example, the code is as follows:

The code is as follows:

Class Person{
//Define static member properties
public static $country = "China";
//Define static member method
public static function myCountry() {
// Internal access to static member properties
echo "I am".self::$country."人
";
}
}
class Student extends Person {
function study() {
echo "I am". parent::$country."人
";
}
}
// Output member attribute value
echo Person::$country."
"; // Output: China
$p1 = new Person();
//echo $p1->country; // Wrong writing
//Access static member methods
Person::myCountry(); // Output: I am Chinese
// Static methods can also be accessed through objects:
$p1->myCountry();

// Output member attribute values in subclasses
echo Student::$country."
"; // Output: China
$t1 = new Student();
$t1->study(); // Output: I am Chinese
?>

Running this example, output:
China
I am Chinese
I am Chinese
China
I am Chinese

Summary: To access static member properties or methods inside a class, use self:: (note not $slef), the code is as follows:

The code is as follows:

slef:: $country

slef:: myCountry()

To access the static member properties or methods of the parent class in a subclass, use parent:: (note not $parent), the code is as follows:

The code is as follows:

parent:: $country

parent:: myCountry()

External access to static member attributes and methods is class name/subclass name::, the code is as follows:

The code is as follows:

Person::$country

Person::myCountry()

Student::$country

But static methods can also be accessed through ordinary objects.
Example, declare a static variable, the code is as follows:

The code is as follows:

function foo(){
static $int = 0; // correct
static $int = 1+2; // wrong (as it is an expression)
static $int = sqrt(121); // wrong (as it is an expression too)
$int++;
echo $int;
}
?>

Example, an example of using static variables, the code is as follows:

The code is as follows:

function Test()
{
static $w3sky = 0;
echo $w3sky;
$w3sky++;
}
?>

Now, each call to the Test() function will output the value of $w3sky and increment it by one.

Static variables also provide a way to deal with recursive functions. A recursive function is a function that calls itself. Be careful when writing a recursive function, because it may recurse infinitely. You must ensure that there is a sufficient method to terminate the recursion. Let’s take a look at this simple function that recursively counts to 10, using the static variable $count to determine when to stop.

Example, static variables and recursive functions, the code is as follows:

The code is as follows:

function Test()
{
static $count = 0;

$count++;
echo $count;
if ($count < 10) {
Test();
}
$count--;
}
?>

Note: Static variables can be declared according to the above example. If the result of an expression is used to assign a value to it in the declaration, it will cause a parsing error.