Shulou(Shulou.com)06/03 Report--

This article mainly introduces "how to write the properties and methods and delayed binding of static variables in PHP object-oriented programming". In daily operations, it is believed that many people have doubts about how to write the properties and methods and delayed binding of static variables in PHP object-oriented programming. The editor consulted all kinds of materials and sorted out simple and useful operation methods. I hope it will be helpful for you to answer the doubt of "how to write the properties and methods of PHP object-oriented programming static variables and delay binding"! Next, please follow the editor to study!

The Static keyword is used to define static methods and properties, and static can also be used to define static variables and later static bindings.

1. Static variable static variable

Static variables exist only in the local function domain, but their values are not lost when the program executes out of this scope. That is, the next time this function is executed, the variable will still remember the original value. To define a variable as static, simply precede the variable with the static keyword.

The copy code is as follows:

Function testing ()

{

Static $a = 1

$a * = 2

Echo $a. "\ n"

}

Testing ()

Testing ()

Testing ()

Testing ()

/ * *

* 2

* 4

* 8

* 16

* [Finished in 0.1s]

, /

Static variables also provide a way to deal with recursive functions. A recursive function is a function that calls itself. Be careful when writing recursive functions, as it may be infinitely recursive. You must ensure that there is an adequate way to abort recursion.

In this example, the testing () function saves the value of the $a variable internally after each execution. The next time the testing () function is called, the value of $an is restored, and then the testing () function multiplies this value by 2 and prints it. The initial default value of the variable is 1, and this assignment occurs only when the variable is initialized for the first time. This operation is not called each time the function is executed.

2. The use of static elements in the class

There are two main uses of the static keyword in a class, one to define static members and the other to define static methods. If a class property or method is declared static, it can be accessed directly without instantiating the class. Static properties cannot be accessed through an object instantiated by a class (but static methods can). Static properties cannot be accessed by an object through the-> operator. Inside the class, we can use the scoping operator to access variables at different levels of scope.

2.1, static attribute

Because static methods do not need to be called through an object, the pseudo variable $this is not available in static methods. You can think of a static variable as belonging to the entire class rather than an instance of the class. Unlike normal instance variables, static properties retain only one variable value, which is valid for all instances, that is, all instances share this property.

The copy code is as follows:

Class MyObject

{

Public static $a = 0

Function MyMethod ()

{

Self::$a + = 2

Echo self::$a. "\ n"

}

}

$instance1 = new MyObject ()

$instance1-> MyMethod ()

$instance2 = new MyObject ()

$instance2-> MyMethod ()

/ * *

*

* 2

* 4

* [Finished in 0.1s]

*

, /

The $this metric is the current instance of the class and is a reference to the calling object.

Self:: represents the class itself, and the self:: scope qualifier must be followed by a $symbol, which cannot be used in code outside the class, and it does not recognize its position in the inheritance tree hierarchy. When using self:: scope in an extension class, self can call methods declared in the base class, but it always calls methods that have been overridden in the extension class.

Parent:: in the extension class, if the method of the base class is overridden, if you want to access the method of the base class, you can use parent::

Static:: eliminates the need for self:: and parent::. When you want to point to the final class that implements the function, you can use static, which evaluates the members of the last class in the inheritance hierarchy immediately before the code is executed.

2.3. Static method

The rules for static methods are the same as static variables. Use the static keyword to mark a method as a static method, which can be accessed through the name of the class and the scoping operator (::).

There is an important difference between static and non-static methods: when calling static methods, we no longer need to have an instance of the class.

The copy code is as follows:

Class MyObjectBase

{

Static function MyMethod ()

{

Static::MyOtherMethod ()

}

Static function MyOtherMethod ()

{

Echo 'called from MyObject.'

}

}

Class MyExtendObject extends MyObjectBase

{

Static function MyOtherMethod ()

{

Echo 'called from MyExtendObject.'

}

}

MyExtendObject::MyMethod ()

The above example code will correctly call the MyOtherMethod method in MyExtendObject to output called from MyExtendObject. [Finished in 0.1s] .

If a method does not contain the $this variable, then the method should be static. If you don't need an instance of a class, you should also use a static class, which eliminates the need for instantiation. In addition, the $this variable cannot be used in static methods because static methods do not belong to a particular instance.

2.4, delayed binding

Static:: eliminates the need for self:: and parent::. When you want to point to the final class that implements the function, you can use static, which evaluates the members of the last class in the inheritance hierarchy immediately before the code is executed. This process is called delayed binding.

3. Summary

Use the static keyword to create static variables and provide a default initialization value. A static variable is a modified function variable whose value remains intact after the execution of a function is completed.

The static keyword can also be used in classes to decorate properties and methods. When used on a property, it no longer saves a value for an instance, but a value for the entire class itself, and static properties can be shared among members.

To access static methods, you can use (::), which is called the scope qualifier. To the left of this operator can be a class name or a predefined scope, which includes self parent static. To the right of the operator is a static method and property.

At this point, the study on "how to write PHP object-oriented programming static variable properties and methods and delayed binding" is over. I hope to be able to solve everyone's doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.