जब बायां हिस्सा ऑब्जेक्ट इंस्टेंस होता है, तो आप उपयोग करते हैं ->
। अन्यथा, आप उपयोग करते हैं ::
।
इसका मतलब है कि इसका ->
उपयोग ज्यादातर उदाहरण के सदस्यों तक पहुंचने के लिए किया जाता है (हालांकि इसका उपयोग स्थैतिक सदस्यों तक पहुंचने के लिए भी किया जा सकता है, इस तरह के उपयोग को हतोत्साहित किया जाता है), जबकि ::
आमतौर पर स्थैतिक सदस्यों तक पहुंचने के लिए उपयोग किया जाता है (हालांकि कुछ विशेष मामलों में, इसका उपयोग उदाहरण के सदस्यों तक पहुंचने के लिए किया जाता है। )।
सामान्य तौर पर, ::
के लिए प्रयोग किया जाता है गुंजाइश संकल्प , और यह हो सकता है या तो एक वर्ग के नाम, parent
, self
, या (पीएचपी 5.3 में) static
अपनी बाईं ओर। parent
उस वर्ग के सुपरक्लास के दायरे को संदर्भित करता है जहां इसका उपयोग किया जाता है; self
उस वर्ग के दायरे को संदर्भित करता है जहां इसका उपयोग किया जाता है; static
"स्कोप" कहलाता है ( देर से स्थैतिक बाइंडिंग देखें )।
नियम यह है कि एक कॉल के साथ ::
एक उदाहरण कॉल है अगर और केवल अगर:
- लक्ष्य विधि को स्थिर घोषित नहीं किया गया है और
- कॉल के समय संगत ऑब्जेक्ट संदर्भ होता है, जिसका अर्थ है कि ये सही होना चाहिए:
- कॉल एक ऐसे संदर्भ से किया जाता है जहां
$this
मौजूद है और
- की कक्षा
$this
या तो कहे जाने वाली विधि का वर्ग है या इसका उपवर्ग है।
उदाहरण:
class A {
public function func_instance() {
echo "in ", __METHOD__, "\n";
}
public function callDynamic() {
echo "in ", __METHOD__, "\n";
B::dyn();
}
}
class B extends A {
public static $prop_static = 'B::$prop_static value';
public $prop_instance = 'B::$prop_instance value';
public function func_instance() {
echo "in ", __METHOD__, "\n";
/* this is one exception where :: is required to access an
* instance member.
* The super implementation of func_instance is being
* accessed here */
parent::func_instance();
A::func_instance(); //same as the statement above
}
public static function func_static() {
echo "in ", __METHOD__, "\n";
}
public function __call($name, $arguments) {
echo "in dynamic $name (__call)", "\n";
}
public static function __callStatic($name, $arguments) {
echo "in dynamic $name (__callStatic)", "\n";
}
}
echo 'B::$prop_static: ', B::$prop_static, "\n";
echo 'B::func_static(): ', B::func_static(), "\n";
$a = new A;
$b = new B;
echo '$b->prop_instance: ', $b->prop_instance, "\n";
//not recommended (static method called as instance method):
echo '$b->func_static(): ', $b->func_static(), "\n";
echo '$b->func_instance():', "\n", $b->func_instance(), "\n";
/* This is more tricky
* in the first case, a static call is made because $this is an
* instance of A, so B::dyn() is a method of an incompatible class
*/
echo '$a->dyn():', "\n", $a->callDynamic(), "\n";
/* in this case, an instance call is made because $this is an
* instance of B (despite the fact we are in a method of A), so
* B::dyn() is a method of a compatible class (namely, it's the
* same class as the object's)
*/
echo '$b->dyn():', "\n", $b->callDynamic(), "\n";
आउटपुट:
B :: $ prop_static: B :: $ prop_static मान
B :: func_static (): B :: func_static में
$ b-> prop_instance: B :: $ prop_instance मूल्य
$ b-> func_static (): B :: func_static में
$ बी> func_instance ():
बी में :: func_instance
ए में :: func_instance
ए में :: func_instance
$ A-> dyn ():
A :: callDynamic में
गतिशील वंश में (__callStatic)
$ बी> dyn ():
A :: callDynamic में
गतिशील वंश में (__call)