Nested or Inner Class in PHP

Intro:

Nested classes relate to other classes a little differently than outer classes. Taking Java as an example:

Non-static nested classes have access to other members of the enclosing class, even if they are declared private. Also, non-static nested classes require an instance of the parent class to be instantiated.

OuterClass outerObj = new OuterClass(arguments);outerObj.InnerClass innerObj = outerObj.new InnerClass(arguments);

There are several compelling reasons for using them:

• It is a way of logically grouping classes that are only used in one place.

If a class is useful to only one other class, then it is logical to relate and embed it in that class and keep the two together.

• It increases encapsulation.

Consider two top-level classes, A and B, where B needs access to members of A that would otherwise be declared private. By hiding class B within class A, A's members can be declared private and B can access them. In addition, B itself can be hidden from the outside world.

• Nested classes can lead to more readable and maintainable code.

A nested class usually relates to it's parent class and together form a "package"

In PHP

You can have similar behavior in PHP without nested classes.

If all you want to achieve is structure/organization, as Package.OuterClass.InnerClass, PHP namespaces might sufice. You can even declare more than one namespace in the same file (although, due to standard autoloading features, that might not be advisable).

namespace;class OuterClass {}namespace OuterClass;class InnerClass {}

If you desire to emulate other characteristics, such as member visibility, it takes a little more effort.

Defining the "package" class

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()");            }        }    }}

Use case

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();        }    }}

Testing

$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)

Output:

Call from parent -> I'm Package protected methodI'm Package protected methodSiblingsCall from Package -> I'm Package protected methodFatal error: Call to protected Package::__construct() from invalid context

NOTE:

I really don't think trying to emulate innerClasses in PHP is such a good idea. I think the code is less clean and readable. Also, there are probably other ways to achieve similar results using a well established pattern such as the Observer, Decorator ou COmposition Pattern. Sometimes, even simple inheritance is sufficient.

Real nested classes with public/protected/private accessibility were proposed in 2013 for PHP 5.6 as an RFC but did not make it (No voting yet, no update since 2013 - as of 2021/02/03):

https://wiki.php.net/rfc/nested_classes

class foo {    public class bar {     }}

At least, anonymous classes made it into PHP 7

https://wiki.php.net/rfc/anonymous_classes

From this RFC page:

Future Scope

The changes made by this patch mean named nested classes are easier to implement (by a tiny bit).

So, we might get nested classes in some future version, but it's not decided yet.

You cannot do this in PHP. However, there are functional ways to accomplish this.

For more details please check this post:How to do a PHP nested class or nested methods?

This way of implementation is called fluent interface: http://en.wikipedia.org/wiki/Fluent_interface