The use and difference of static and Non-static methods in PHP

The static keyword is used to decorate properties, methods, and to describe these properties, methods as static properties, and static methods.

The static keyword declares that a property or method is related to a class, not to a particular instance of a class, and therefore such a property or method is also called a class property or class method

If access control permission allows, you do not have to create the class object and use the class name plus two colons "::" to invoke it directly.

The static keyword can be used to modify variables, methods.

static properties and static methods in a class can be accessed directly without instantiating it.

Static properties and methods that can access only static properties and methods, and cannot have classes that access non-static properties and methods. Because static properties and methods are created, there may not be any instances of this class that can be tuned

Use.

Static properties, in memory only one copy, shared for all instances.

Use self:: keyword to access static members of the current class.

All instances of a class that share static properties in a class.

That is, even if there are multiple instances in memory, there is only one copy of the static property.

The following example sets a counter $count property, setting private and static adornments.

In this way, the $count property is not directly accessible to the outside world. As a result of the program running, we also see that multiple instances are using the same static $count property.

<?php
Class User
{
private static $count = 0; Log the logon status of all users.
Public Function __construct () {
Self:: $count = self:: $count + 1;
}
Public Function GetCount () {
Return self:: $count;
}
Public Function __destruct () {
Self:: $count = self:: $count-1;
}
}
$user 1 = new user ();
$user 2 = new User ();
$user 3 = new User ();
echo "Now here have". $user 1->getcount (). "User";
echo "<br/>";
Unset ($user 3);
echo "Now here have". $user 1->getcount (). "User";
?>

Static properties are called directly
Static properties can be used directly without instantiating them and can be used directly when the class is not yet created.

The way you use it is: Class Name:: Static property name

<?php
Class Math
{
public static $PI = 3.14;
}
Find the area of a garden with a radius of 3.
$r = 3;
echo "radius is the area of the $r is <br/>";
echo Math:: $pi * $r * $R;
echo "<br/><br/>";
Here I think 3.14 is not accurate enough, I set it more accurate.
Math:: $pi = 3.141592653589793;
echo "radius is the area of the $r is <br/>";
echo Math:: $pi * $r * $R;
?>


Class is not created, static properties can be used directly. When is the static property created in memory? There is no relevant information in PHP. Refer to the concepts in Java to explain that they should also be generic

。 Static properties and methods that are created when a class is invoked.

static method
Static methods do not require that the class being instantiated be used directly.

The method used is class name:: Static method Name

Let's continue to write this math class for mathematical calculations. We designed a method to calculate the maximum value. Since it is a mathematical operation, we do not need to instantiate this class, if this method

It's much more convenient if you can bring it over. We are just this class designed to demonstrate the static method. The max () function comparison value is provided in PHP.

View Plaincopy to Clipboardprint?
<?php
Class Math
{
public static function Max ($num 1, $num 2) {
Return $num 1 > $num 2? $num 1: $num 2;
}
}
$a = 99;
$b = 88;
echo "shows the maximum value $a and $b is";
echo "<br/>";
Echo Math::max ($a, $b);
echo "<br/>";
echo "<br/>";
echo "<br/>";
$a = 99;
$b = 100;
echo "shows the maximum value $a and $b is";
echo "<br/>";
Echo Math::max ($a, $b);
?>

How static methods Call static methods
The first example, when a static method calls another static method, uses self::

<?php
The math class that implements the maximum comparison.
Class Math
{
public static function Max ($num 1, $num 2) {
Return $num 1 > $num 2? $num 1: $num 2;
}
public static function Max3 ($num 1, $num 2, $num 3) {
$num 1 = Self::max ($num 1, $num 2);
$num 2 = Self::max ($num 2, $num 3);
$num 1 = Self::max ($num 1, $num 2);
return $num 1;
}
}
$a = 99;
$b = 77;
$c = 88;
echo "Displays the maximum value of $a $b $c is";
echo "<br/>";
Echo math::max3 ($a, $b, $c);
?>



Static methods Call Static properties
Use self:: Invoke the static properties of this class.

<?php
//
Class Circle
{
public static $PI = 3.14;
public static function Circleacreage ($r) {
return $r * $r * self:: $PI;
}
}
$r = 3;
The area of the echo "Radius $r circle is". Circle::circleacreage ($R);
?>


A static method cannot invoke a Non-static property. Cannot use Self:: Invoke Non-static property.

<?php
This is a wrong way.
Class Circle
{
Public $pi = 3.14;
public static function Circleacreage ($r) {
return $r * $r * self::p i;
}
}
$r = 3;
The area of the echo "Radius $r circle is". Circle::circleacreage ($R);
?>


You cannot use $this to get the value of a non-static property.

Static method calls Non-static methods
In PHP5, non-static methods cannot be invoked in static methods using the $this identity.

<?php
The math class that implements the maximum comparison.
Class Math
{
Public Function Max ($num 1, $num 2) {
echo "Bad<br/>";
Return $num 1 > $num 2? $num 1: $num 2;
}
public static function Max3 ($num 1, $num 2, $num 3) {
$num 1 = $this->max ($num 1, $num 2);
$num 2 = $this->max ($num 2, $num 3);
$num 1 = $this->max ($num 1, $num 2);
return $num 1;
}
}
$a = 99;
$b = 77;
$c = 188;
echo "Displays the maximum value of $a $b $c is";
echo "<br/>";
Echo math::max3 ($a, $b, $c); The same one will complain.
?>

When there is a Non-static method in a class that is self:: called, the system automatically converts this method to a static method.

<?php
The math class that implements the maximum comparison.
Class Math
{
Public Function Max ($num 1, $num 2) {
Return $num 1 > $num 2? $num 1: $num 2;
}
public static function Max3 ($num 1, $num 2, $num 3) {
$num 1 = Self::max ($num 1, $num 2);
$num 2 = Self::max ($num 2, $num 3);
$num 1 = Self::max ($num 1, $num 2);
return $num 1;
}
}
$a = 99;
$b = 77;
$c = 188;
echo "Displays the maximum value of $a $b $c is";
echo "<br/>";
Echo math::max3 ($a, $b, $c);
?>

From PHP100 forum http://bbs.php100.com