Clase Anidada o Interna en PHP

Introducción:

Las clases anidadas se relacionan con otras clases un poco diferente a las clases externas. Tomando Java como ejemplo:

Las clases anidadas no estáticas tienen acceso a otros miembros de la clase que las encierra, incluso si se declaran privadas. Además, las clases anidadas no estáticas requieren que se cree una instancia de la clase padre.

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

Hay varias razones convincentes para usarlos:

• Es una forma de agrupar lógicamente clases que son solo se usa en un solo lugar.

Si una clase es útil solo para otra clase, entonces es lógico relacionarlo e incrustarlo en esa clase y mantener los dos juntos.

• aumenta la encapsulación.

Considere dos clases de alto nivel, A y B, donde B necesita acceso a miembros de A que de otro modo serían declarados privados. Ocultando la clase B dentro de la clase A, los miembros de A pueden ser declarados privados y B puede acceder ellos. Además, B se puede ocultar del mundo exterior.

• Las clases anidadas pueden conducir a un código más legible y mantenible.

Una clase anidada generalmente se relaciona con su clase padre y juntos forman un "paquete"

En PHP

Puede tener un comportamiento similar en PHP sin clases anidadas.

Si todo lo que desea lograr es estructura/organización, como paquete.Clase externa.InnerClass, los espacios de nombres PHP podrían ser suficientes. Incluso puedes declare más de un espacio de nombres en el mismo archivo (aunque, debido a las características de carga automática estándar, eso podría no ser recomendable).

namespace;
class OuterClass {}

namespace OuterClass;
class InnerClass {}

Si desea emular otras características, como la visibilidad de los miembros, se necesita un poco más de esfuerzo.

Definiendo la clase" package "

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

Caso de uso

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

Pruebas

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

Salida:

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

NOTA:

Realmente no creo que tratar de emular innerClasses en PHP sea tan bueno idea. Creo que el código es menos limpio y legible. Además, probablemente hay otras formas de lograr resultados similares utilizando un patrón bien establecido, como el Patrón de composición Observer, Decorator ou. A veces, incluso la simple herencia es suficiente.