परिचय:
नेस्टेड कक्षाएं बाहरी कक्षाओं की तुलना में थोड़ा अलग तरीके से अन्य कक्षाओं से संबंधित हैं। उदाहरण के रूप में जावा लेना:
गैर-स्थैतिक नेस्टेड वर्गों के पास संलग्न वर्ग के अन्य सदस्यों तक पहुंच है, भले ही वे निजी घोषित किए गए हों। इसके अलावा, गैर-स्थैतिक नेस्टेड वर्गों को तत्काल करने के लिए मूल वर्ग के उदाहरण की आवश्यकता होती है।
OuterClass outerObj = new OuterClass(arguments);
outerObj.InnerClass innerObj = outerObj.new InnerClass(arguments);
उनका उपयोग करने के लिए कई सम्मोहक कारण हैं:
- यह तार्किक रूप से समूहन वर्गों का एक तरीका है जो केवल एक ही स्थान पर उपयोग किया जाता है।
यदि कोई वर्ग केवल एक अन्य वर्ग के लिए उपयोगी है, तो उस कक्षा में इसे संबंधित और एम्बेड करना तर्कसंगत है और दोनों को एक साथ रखना है।
- यह एन्कैप्सुलेशन को बढ़ाता है।
दो शीर्ष स्तर की कक्षाओं पर विचार करें, ए और बी, जहां बी को ए के सदस्यों तक पहुंच की आवश्यकता है जो अन्यथा निजी घोषित किया जाएगा। कक्षा बी को कक्षा ए के भीतर छिपाकर, ए के सदस्यों को निजी घोषित किया जा सकता है और बी उन्हें एक्सेस कर सकते हैं। इसके अलावा, बी खुद को बाहरी दुनिया से छिपाया जा सकता है।
- नेस्टेड कक्षाएं अधिक पठनीय और बनाए रखने योग्य कोड को जन्म दे सकती हैं।
एक नेस्टेड क्लास आमतौर पर माता-पिता वर्ग से संबंधित होती है और एक साथ एक "पैकेज" बनाती है
PHP में
आप नेस्टेड वर्गों के बिना PHP में समान व्यवहार कर सकते हैं ।
यदि आप सभी को प्राप्त करना चाहते हैं, तो संरचना / संगठन है, जैसा कि Package.OuterClass.InnerClass, PHP के नामस्थान पर मुकदमा हो सकता है। आप एक ही फ़ाइल में एक से अधिक नामस्थान भी घोषित कर सकते हैं (हालाँकि, मानक ऑटोलडिंग विशेषताओं के कारण, यह उचित नहीं हो सकता है)।
namespace;
class OuterClass {}
namespace OuterClass;
class InnerClass {}
यदि आप अन्य विशेषताओं का अनुकरण करना चाहते हैं, जैसे कि सदस्य दृश्यता, तो यह थोड़ा अधिक प्रयास करता है।
"पैकेज" वर्ग को परिभाषित करना
namespace {
class Package {
/* protect constructor so that objects can't be instantiated from outside
* Since all classes inherit from Package class, they can instantiate eachother
* simulating protected InnerClasses
*/
protected function __construct() {}
/* This magic method is called everytime an inaccessible method is called
* (either by visibility contrains or it doesn't exist)
* Here we are simulating shared protected methods across "package" classes
* This method is inherited by all child classes of Package
*/
public function __call($method, $args) {
//class name
$class = get_class($this);
/* we check if a method exists, if not we throw an exception
* similar to the default error
*/
if (method_exists($this, $method)) {
/* The method exists so now we want to know if the
* caller is a child of our Package class. If not we throw an exception
* Note: This is a kind of a dirty way of finding out who's
* calling the method by using debug_backtrace and reflection
*/
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
if (isset($trace[2])) {
$ref = new ReflectionClass($trace[2]['class']);
if ($ref->isSubclassOf(__CLASS__)) {
return $this->$method($args);
}
}
throw new \Exception("Call to private method $class::$method()");
} else {
throw new \Exception("Call to undefined method $class::$method()");
}
}
}
}
उदाहरण
namespace Package {
class MyParent extends \Package {
public $publicChild;
protected $protectedChild;
public function __construct() {
//instantiate public child inside parent
$this->publicChild = new \Package\MyParent\PublicChild();
//instantiate protected child inside parent
$this->protectedChild = new \Package\MyParent\ProtectedChild();
}
public function test() {
echo "Call from parent -> ";
$this->publicChild->protectedMethod();
$this->protectedChild->protectedMethod();
echo "<br>Siblings<br>";
$this->publicChild->callSibling($this->protectedChild);
}
}
}
namespace Package\MyParent
{
class PublicChild extends \Package {
//Makes the constructor public, hence callable from outside
public function __construct() {}
protected function protectedMethod() {
echo "I'm ".get_class($this)." protected method<br>";
}
protected function callSibling($sibling) {
echo "Call from " . get_class($this) . " -> ";
$sibling->protectedMethod();
}
}
class ProtectedChild extends \Package {
protected function protectedMethod() {
echo "I'm ".get_class($this)." protected method<br>";
}
protected function callSibling($sibling) {
echo "Call from " . get_class($this) . " -> ";
$sibling->protectedMethod();
}
}
}
परिक्षण
$parent = new Package\MyParent();
$parent->test();
$pubChild = new Package\MyParent\PublicChild();//create new public child (possible)
$protChild = new Package\MyParent\ProtectedChild(); //create new protected child (ERROR)
आउटपुट:
Call from parent -> I'm Package protected method
I'm Package protected method
Siblings
Call from Package -> I'm Package protected method
Fatal error: Call to protected Package::__construct() from invalid context
ध्यान दें:
मुझे नहीं लगता कि PHP में इनरक्लासेस का अनुकरण करने की कोशिश करना इतना अच्छा विचार है। मुझे लगता है कि कोड कम साफ और पठनीय है। इसके अलावा, ऑब्जर्वर, डेकोरेटर कहां कॉंपोज़ पैटर्न जैसे एक अच्छी तरह से स्थापित पैटर्न का उपयोग करके समान परिणाम प्राप्त करने के लिए संभवतः अन्य तरीके हैं। कभी-कभी, साधारण विरासत भी पर्याप्त होती है।