Classe imbriquée ou intérieure en PHP

Intro:

Les classes imbriquées

se rapportent à d'autres classes un peu différemment des classes externes. Prenons L'exemple de Java:

les classes imbriquées Non statiques ont accès aux autres membres de la classe environnante, même si elles sont déclarées privées. De plus, les classes imbriquées non statiques nécessitent qu'une instance de la classe mère soit instanciée.

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

il y a plusieurs raisons impérieuses de les utiliser:

• c'est une façon de regrouper logiquement des classes qui ne sont utilisées qu'à un seul endroit.

Si une classe est utile à une seule autre classe, alors il est logique de reliez et intégrez - le dans cette classe et gardez les deux ensemble.

• il augmente l'encapsulation.

envisager deux classes supérieures, A et B, où B a besoin d'accès de les membres d'Un qui serait par ailleurs déclaré privé. En cachant la classe B dans la classe A, Les membres de A peuvent être déclarés privés et B peut accéder ils. En outre, B lui-même peut être caché du monde extérieur.

• les classes imbriquées peuvent conduire à un code plus lisible et maintenable.

une classe imbriquée se rapporte habituellement à sa classe mère et forment ensemble un" paquet

en PHP

vous pouvez avoir comportement similaire dans PHP sans classes imbriquées.

si tout ce que vous voulez réaliser est structure/organisation, comme paquet.OuterClass.InnerClass, espaces de noms PHP pourraient sufice. Vous pouvez même déclarer plus d'un namespace dans le même fichier (bien que, en raison des fonctionnalités de chargement automatique standard, cela pourrait ne pas être conseillé).

namespace;
class OuterClass {}

namespace OuterClass;
class InnerClass {}

si vous désirez imiter d'autres caractéristiques, comme la visibilité des membres, cela demande un peu plus d'efforts.

définissant la classe" colis

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

---

cas d'Utilisation

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

test

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

sortie:

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

---

NOTE:

Je ne pense vraiment pas qu'essayer d'imiter les classes en PHP soit une bonne idée. Je pense que le code est moins propre et lisible. En outre, il y a probablement d'autres façons d'obtenir des résultats similaires en utilisant un modèle bien établi tel que le modèle Observer, Decorator ou COmposition. Parfois, même un simple héritage suffit.