PHP--and + = and:: Usage

=
The relationship between the key and value used for an array in an array
For example:
$a = Array (
' 0 ' = ' 1 ',
' 2 ' = ' 4 ',
);

echo $a [' 0 '];
echo $a [' 2 '];


-
Methods and properties in a class to reference class instances
For example:
Class test{
function Add () {return $this->var++;}
var $var = 0;
}

$a = new Test (); Instantiating object names
echo $a->add ();
Echo $a->var;


：：
Methods for referencing static and static properties in a class
For example
Class test{
public static function test () {
public static $test = 1;
}
}

The static and static properties of a class can be used directly without instantiating the object (using the class name:: Static method Name)

Test::test (); Call the static method test
Test:: $test; To get the value of the $test static property

Note:
Static methods are instantiated and put into memory when they are read to this class or introduced into the class, and non-static classes need new.
Static classes have only one copy of static properties in memory, even if there are multiple instances.



=============================self is a class name that refers to a static class, and $this is an instance name that references a non-static class ===========



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

Use.

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

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

All instances of a class, a static property in a common 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 the private and static adornments.

This way, the $count property is not directly accessible to the outside world. And the results of the program run we also see multiple instances using the same static $count property.


 Class User
{
private static $count = 0; Logs 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 has". $user 1->getcount (). "User";
echo "
";
Unset ($user 3);
echo "Now here has". $user 1->getcount (). "User";
?>

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

Used in the following way: Class Name:: Static property name


 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
";
echo Math:: $pi * $r * $R;
echo "

";
Here I think 3.14 is not accurate enough, I set it more precisely.
Math:: $pi = 3.141592653589793;
echo "radius is the area of the $r is
";
echo Math:: $pi * $r * $R;
?>


Class is not created, static properties can be used directly. When was the static property created in memory? No data was found in PHP. Refer to the concepts in Java to explain that it should also be universal

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

Static methods
Static methods do not require that the class be instantiated to be used directly.

The way to use the class name:: Static method Name

Let's continue writing this math class for mathematical calculations. We design a method to figure out 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 to take 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?

 Class Math
{
public static function Max ($num 1, $num 2) {
Return $num 1 > $num 2? $num 1: $num 2;
}
}
$a = 99;
$b = 88;
echo "Displays the maximum value in $a and $b is";
echo "
";
Echo Math::max ($a, $b);
echo "
";
echo "
";
echo "
";
$a = 99;
$b = 100;
echo "Displays the maximum value in $a and $b is";
echo "
";
Echo Math::max ($a, $b);
?>

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


 The math class that implements the maximum value 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 in the $a $b $c is";
echo "
";
Echo math::max3 ($a, $b, $c);
?>



static method call static property
Use self:: Call the static property of this class.


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


A static method cannot invoke a non-static property. You cannot use Self:: Call a non-static property.


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


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

Static method calls a non-static method
In PHP5, a non-static method cannot be called using $this identity in a static method.


 The math class that implements the maximum value comparison.
Class Math
{
Public Function Max ($num 1, $num 2) {
echo "Bad
";
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 in the $a $b $c is";
echo "
";
Echo math::max3 ($a, $b, $c); The same one will make an error.
?>

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


 The math class that implements the maximum value 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 in the $a $b $c is";
echo "
";
Echo math::max3 ($a, $b, $c);
?>

---------------------------------------------
The meaning of this in PHP


The following defines a cart class

 Class Cart
{
var $items; Items in the shopping cart

Put $num a $artnr in the car

function Add_item ($ARTNR, $num)
{
$this->items[$artnr] + = $num;
}

Take $num $artnr out of a car.

function Remove_item ($ARTNR, $num)
{
if ($this->items[$artnr] > $num) {
$this->items[$artnr]-= $num;
return true;
} else {
return false;
}
}
}
?>
To illustrate the problem in a piece of code, within the definition of a class, you cannot tell what name the object is accessible: When you write the Cart class, you do not know that the name of the object will be named $cart or $another _cart. Thus you cannot use the $cart->items in the class. However, for a class-defined internal access to its own functions and variables, pseudo-variable $this can be used to achieve this purpose. $this variable can be interpreted as "my own" or "current object". Thus ' $this->>items[$artnr] + = $num ' can be understood as "the $ARTNR counter of my own array of items plus $num" or "$artnr counter in the current object's array of items $num".

