Analysis of the difference between static classes and static variables in php_PHP tutorial

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

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

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

　2. Directly call class methods/variables: class::attribute/function, whether 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 without using $this, that is, no non-static variables/methods are called. Of course, there is no problem with calling static variables/methods.

Then let’s take a look at the difference between using $object ject->… 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 a class member or method as static means that it 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:

[Code]php code:

　01

　02Class Person{

　03 // Define static member attributes

　04 public static $country = "China";

　05 // Define static member methods

　06 public static function myCountry() {

　07 // Internal access to static member properties

　08 echo "I am".self::$country."人
";

　09}

　10}

　11class Student extends Person {

　12 function study() {

　13 echo "I am". parent::$country."人
";

　14}

　15}

　16//Output member attribute value

　17echo Person::$country."
"; // Output: China

　18$p1 = new Person();

　19//echo $p1->country; // Wrong writing

　20//Access static member methods

　21Person::myCountry(); // Output: I am Chinese

　22// Static methods can also be accessed through objects:

　23$p1->myCountry();

　24

　25//Output member attribute values ​​in subclasses

　26echo Student::$country."
"; // Output: China

　27$t1 = new Student();

　28$t1->study(); // Output: I am Chinese

　29?>

Running this example, output:

China

I am Chinese

I am Chinese

China

I am Chinese

Summary: To access static member attributes or methods inside a class, use self:: (note not $slef), 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:

parent:: $country

parent:: myCountry()

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

Person::$country

Person::myCountry()

Student::$country

But static methods can also be accessed through ordinary objects.

Example, declare static variables, the code is as follows:

[Code]php code:

　1

　2 function foo(){

　3 static $int = 0;// correct

　4 static $int = 1 2; // wrong (as it is an expression)

　5 static $int = sqrt(121); // wrong (as it is an ex pression too)

　6 $int ;

　7 echo $int;

　8}

9?>

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

　[Code]php code:

　1

　2 function Test()

　3 {

　4 static $w3sky = 0;

　5 echo $w3sky;

　6 $w3sky ;

　7}

　8?>

Now, each time the Test() function is called, the value of $w3sky will be output and incremented 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:

　[Code]php code:

　01

　02 function Test()

　03 {

　04 static $count = 0;

　05

　06 $count ;

　07 echo $count;

　08 if ($count < 10) {

　09 Test();

　10}

　11 $count--;

　12}

　13?>

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.