Utilize PHP’s scope resolution operator (::)

This article mainly introduces the use of PHP's scope resolution operator (::), which has certain reference value. Now I share it with you. Friends in need can refer to it

Watch joomla today I didn't realize it until I read the source code. It turns out that this operator can also access non-static methods of the class. It really doesn't surprise me. I have always thought that the scope resolution operator can only access static methods and static member variables of a class.

Scope Resolution Operator (::)
I realized this when I looked at the joomla source code today. It turns out that this operator can also access non-static methods of the class. It really doesn't surprise me. I have always thought that the scope resolution operator can only access static methods and static member variables of a class.
If you don’t believe it, here is a simple little test code that can prove this.

class A{ 
private $_name = 'A'; 
function __construct(){ 
echo 'A construct 
'; 
} 
function test(){ 
echo 'A test() 
'; 
} 
} 
class B extends A{ 
private $_name = 'B'; 
function __construct(){ 
parent::__construct(); 
echo 'B construct 
'; 
} 
function test(){ 
echo 'B test()'; 
} 
} 
A::test(); 
echo '######### 
'; 
B::test();

The result of inputting this code is:

A test() 
######### 
B test()

Although test() in class A and test in class B are not static methods, you can still use "class name:: Method name (parameter list)" style to make a correct call. Its effect is the same as new an instance of a class, and then using this instance to call the
test method.
However, if I need to print the name attribute in the test method, what will happen if I call it directly with ::? Let’s first modify the above code.

class A{ 
private $_name = 'A'; 
function __construct(){ 
echo 'A construct 
'; 
} 
function test(){ 
echo 'A test() 
', $this->$_name,'
'; 
} 
} 
class B extends A{ 
private $_name = 'B'; 
function __construct(){ 
parent::__construct(); 
echo 'B construct 
'; 
} 
function test(){ 
echo 'B test()', $this->_name,'
'; 
} 
} 
A::test(); 
echo '######### 
'; 
B::test();

The result of running the above code is as follows:

Fatal error: Using $this when not in object context in D:\www\test\scoperefe.php on line 9 
[html]

Some friends said it. You have not instantiated class A at all. Of course, you cannot directly access the member variable $_name using $this->_name. So, can you just change it to self::$_name?
Just do it, now modify the above code

[code] 
class A{ 
private $_name = 'A'; 
function __construct(){ 
echo 'A construct 
'; 
} 
function test(){ 
echo 'A test() 
', self::$_name,'
'; 
} 
} 
class B extends A{ 
private $_name = 'B'; 
function __construct(){ 
parent::__construct(); 
echo 'B construct 
'; 
} 
function test(){ 
echo 'B test()', $this->_name,'
'; 
} 
} 
A::test(); 
echo '######### 
'; 
B::test();

Run the above code again, the results are as follows:

A test() Fatal error: Access to undeclared static property: A::$_name in D:\www\test\scoperefe.php on line 9

Oh, it turns out that you cannot use the self keyword to access A non-static method of the current class.
Now, if you want to call this method correctly, there are two ways:
1. First instantiate the class, and then use the object to call it directly using $this->_name;
2 , Set the member variable $_name to static;
I believe everyone can handle the above problem correctly.
In fact, what I really want to say is:
If a method can be called without instantiation, then we'd better modify this method with the static keyword. When implementing a method, only the static member variables of the class are called. In this way, the problems encountered above will not occur.
If a method is not set to static method. Then, the safest way is to use the instance object to make the call. It is safer, because you may need to modify the implementation of the method at some point. When modifying, you may have to call the
non-static members of the class. Variables (because, to a large extent, when modifying the implementation of the method, we have forgotten to call it directly with the class name).
Personal humble opinion.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

About attribute injection and method injection of component behavior of Yii framework in PHP

About PHP self Usage analysis of defining serialization interface Serializable

The above is the detailed content of Utilize PHP’s scope resolution operator (::). For more information, please follow other related articles on the PHP Chinese website!