The usage and difference between static classes and static variables in php

This article mainly introduces the difference between the usage of static classes and static variables in PHP. It analyzes the definition, function and usage skills of static classes and static variables in PHP in more detail with examples. Friends in need can refer to it

The example of this article analyzes the difference between the usage of static classes and static variables in PHP. Share it with everyone for your reference. The specific analysis is as follows:

static is to define a static object or static variable. Regarding the characteristics of variables or class methods defined by static, we will know after reading the relevant examples in this article.

1. Create an 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 , it is necessary to change that $this is not used in the method, that is, non-static variables/methods are not called. Of course, there is no problem with calling static variables/methods.

Then let’s take a look at using $object->... and What are the differences between using class::…:

1. When using $object->…, you need to execute the constructor to create an object.

2. When using class: :... calls static methods/variables without executing the constructor to create objects.

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

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

static: declare a class member or method as static, you can access it directly without instantiating the class. You cannot access the static members through an object (except for static methods). Static members belong to the class, not to the class. Any object instance, but object instances of classes can be shared.

Example, the code is as follows:

The code is as follows:

<?php 
Class Person{ 
    // 定义静态成员属性 
    public static $country = "中国"; 
    // 定义静态成员方法 
    public static function myCountry() { 
        // 内部访问静态成员属性 
        echo "我是".self::$country."人<br />"; 
    } 
} 
class Student extends Person { 
    function study() { 
        echo "我是". parent::$country."人<br />"; 
    } 
} 
// 输出成员属性值 
echo Person::$country."<br />";  // 输出：中国 
$p1 = new Person(); 
//echo $p1->country;   // 错误写法 
// 访问静态成员方法 
Person::myCountry();   // 输出：我是中国人 
// 静态方法也可通过对象访问： 
$p1->myCountry(); 
 
// 子类中输出成员属性值 
echo Student::$country."<br />"; // 输出：中国 
$t1 = new Student(); 
$t1->study();    // 输出：我是中国人 
?>

Run the example, output:
中国
我是中国人
我是中国人
中国
我是中国人

Summary: To access static member properties or methods within a class, use self:: (Note that it is 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 the subclass, use parent:: (note that it is not $parent ), the code is as follows:

The code is as follows:

parent:: $country
parent:: myCountry()

External access to static membersProperties and methods is the 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.
For example, declare static variables, the code is as follows:

The code is as follows:

<?PHP 
   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:

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

Now, every time Test() is called The function will output the value of $w3sky and add one.

Static variables also provide a way to deal with recursive functions. A recursive function is a function that calls itself. When writing a recursive function Be careful, because the recursion may continue indefinitely, you must ensure that there is a sufficient method to terminate the recursion. Let's consider this simple function to recursively count to 10, and use 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:

<?PHP 
   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 expression## is used in the declaration Assigning the result of # to it will cause a parsing error.

---

In PHP, there are two ways to access class methods/variables:
1. Create an object $object = new Class(), and then use "->" to call: $object-> attribute/function, provided 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:
b1) If it is a static method, there are no special conditions;
b2) If it is a non-static method, it needs to be changed if it is not used in the method. $this means that non-static variables/methods are not called. Of course, there is no problem with calling static variables/methods.

Then let’s take a look at the difference between using $object->… and using class::…:
1. When using $object->…, you need to execute the constructor to create the object;
2. Use class::... to call static methods/variables, and there is no need to execute 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?
The differences still obviously exist, as follows:
1. Static variables
Static members only retain one variable value, and this variable value is valid for all instances, that is to say, all instances share this member.
2. Static methods
Static methods can be called directly using class::..., while non-static methods need to meet certain restrictions before they can be called using class::.. methods, as mentioned before

The above is the detailed content of The usage and difference between static classes and static variables in php. For more information, please follow other related articles on the PHP Chinese website!