Comparative analysis of usage examples of 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:

<?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 this example, the output is:
中国
I am China People
我是中国人
中国
我是中国人

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 parent class static member attributes or methods in a subclass, use parent:: (note not $parent), the code is as follows:

parent:: $country
parent:: myCountry()

External access to static membersAttributes and Method is the 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:

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

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

Now, every 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 are sufficient methods. To stop the recursion, this simple function 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:

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

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