Pregunta Clase anidada o interna en PHP


Estoy construyendo un Clase de usuario para mi nuevo sitio web, sin embargo esta vez estaba pensando en construirlo un poco diferente ...

Yo sé eso C ++, Java e incluso Rubí (y probablemente otros lenguajes de programación) permite clases anidadas / internas dentro de la clase principal que permite hacer que el código esté más orientado a objetos y organizado.

En PHP, me gustaría hacer algo así:

<?php
    public class User {
        public $userid;
        public $username;
        private $password;

        public class UserProfile {
            // Some code here
        }

        private class UserHistory {
            // Some code here
        }
    }
?>

¿Es eso posible en PHP? ¿Cómo puedo lograrlo?


ACTUALIZAR

Si es imposible, ¿las futuras versiones de PHP podrían ser compatibles con las clases anidadas?


74
2018-05-07 16:39


origen


Respuestas:


Introducción:

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

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

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 solo se usan 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 nivel superior, A y B, donde B necesita acceso a   miembros de A que de otro modo serían declarados privados. Al esconder la clase   B dentro de la clase A, los miembros de A pueden declararse privados y B puede acceder   ellos. Además, B puede ocultarse 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 principal y juntos forman un "paquete"

En PHP

Tu puedes tener similar comportamiento en PHP sin clases anidadas.

Si todo lo que quiere lograr es estructura / organización, como Package.OuterClass.InnerClass, los espacios de nombres PHP pueden ser suficientes. Incluso puede declarar más de un espacio de nombres en el mismo archivo (aunque, debido a las características de carga automática estándar, puede que no sea aconsejable).

namespace;
class OuterClass {}

namespace OuterClass;
class InnerClass {}

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

Definiendo la clase "paquete"

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 una buena idea. Creo que el código es menos limpio y legible. Además, probablemente existan otras formas de lograr resultados similares utilizando un patrón bien establecido como el Observer, Decorator ou COmposition Pattern. A veces, incluso la herencia simple es suficiente.


109
2018-05-07 17:17



Clases anidadas reales con public/protected/private la accesibilidad se propuso en 2013 para PHP 5.6 como un RFC pero no lo hizo (No hay votación aún, no hay actualización desde 2013 - a partir de 2016/12/29)

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

class foo {
    public class bar {

    }
}

Al menos, las clases anónimas lo hicieron en PHP 7

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

De esta página de RFC:

Alcance futuro

Los cambios realizados por este parche con el nombre de clases anidadas son más fáciles de implementar (por un poquito).

Entonces, podríamos obtener clases anidadas en alguna versión futura, pero todavía no está decidido.


15
2017-07-16 12:39



no poder haz esto en PHP. Sin embargo, hay funcional formas de lograr esto.

Para más detalles, consulte esta publicación: ¿Cómo hacer una clase anidada PHP o métodos anidados?

Esta forma de implementación se denomina interfaz fluida: http://en.wikipedia.org/wiki/Fluent_interface


8
2018-05-07 16:46



No puedes hacerlo en PHP. PHP admite "incluir", pero ni siquiera puede hacer eso dentro de una definición de clase. No hay muchas opciones geniales aquí.

Esto no responde su pregunta directamente, pero puede estar interesado en "Namespaces", una terrible sintaxis \ hackeada \ en \ top \ de PHP OOP: http://www.php.net/manual/en/language.namespaces.rationale.php


3
2018-05-07 16:43



Desde PHP versión 5.4 puedes forzar la creación de objetos con constructor privado a través de la reflexión. Se puede usar para simular clases anidadas de Java. Código de ejemplo:

class OuterClass {
  private $name;

  public function __construct($name) {
    $this->name = $name;
  }

  public function getName() {
    return $this->name;
  }

  public function forkInnerObject($name) {
    $class = new ReflectionClass('InnerClass');
    $constructor = $class->getConstructor();
    $constructor->setAccessible(true);
    $innerObject = $class->newInstanceWithoutConstructor(); // This method appeared in PHP 5.4
    $constructor->invoke($innerObject, $this, $name);
    return $innerObject;
  }
}

class InnerClass {
  private $parentObject;
  private $name;

  private function __construct(OuterClass $parentObject, $name) {
    $this->parentObject = $parentObject;
    $this->name = $name;
  }

  public function getName() {
    return $this->name;
  }

  public function getParent() {
    return $this->parentObject;
  }
}

$outerObject = new OuterClass('This is an outer object');
//$innerObject = new InnerClass($outerObject, 'You cannot do it');
$innerObject = $outerObject->forkInnerObject('This is an inner object');
echo $innerObject->getName() . "\n";
echo $innerObject->getParent()->getName() . "\n";

3
2018-01-04 20:08



Según el comentario de Xenon a la respuesta de Anıl Özselgin, las clases anónimas se han implementado en PHP 7.0, que es lo más parecido a las clases anidadas que obtendrás en este momento. Aquí están los RFC relevantes:

Clases anidadas (estado: retirado)

Clases anónimas (estado: implementado en PHP 7.0)

Un ejemplo para la publicación original, así es como se vería tu código:

<?php
    public class User {
        public $userid;
        public $username;
        private $password;

        public $profile;
        public $history;

        public function __construct() {
            $this->profile = new class {
                // Some code here for user profile
            }

            $this->history = new class {
                // Some code here for user history
            }
        }
    }
?>

Esto, sin embargo, viene con una advertencia muy desagradable. Si usa un IDE como PHPStorm o NetBeans, y luego agregue un método como este al User clase:

public function foo() {
  $this->profile->...
}

... adiós, autocompletado. Este es el caso incluso si codifica las interfaces (el I en SOLID), usando un patrón como este:

<?php
    public class User {
        public $profile;

        public function __construct() {
            $this->profile = new class implements UserProfileInterface {
                // Some code here for user profile
            }
        }
    }
?>

A menos que sean sus únicas llamadas a $this->profile son de la __construct() método (o cualquier método) $this->profile se define en) entonces no obtendrá ningún tipo de sugerencia de tipo. Su propiedad está esencialmente "oculta" a su IDE, haciendo la vida muy difícil si confía en su IDE para autocompletar, olfatear códigos y refactorizar.


2
2018-01-31 23:14



Está esperando votar como RFC https://wiki.php.net/rfc/anonymous_classes


1
2018-03-19 11:53



Creo que escribí una solución elegante a este problema mediante el uso de espacios de nombres. En mi caso, la clase interna no necesita conocer su clase principal (como la clase interna estática en Java). Como ejemplo hice una clase llamada 'Usuario' y una subclase llamada 'Tipo', utilizada como referencia para los tipos de usuario (ADMIN, OTHERS) en mi ejemplo. Saludos.

User.php (archivo de clase de usuario)

<?php
namespace
{   
    class User
    {
        private $type;

        public function getType(){ return $this->type;}
        public function setType($type){ $this->type = $type;}
    }
}

namespace User
{
    class Type
    {
        const ADMIN = 0;
        const OTHERS = 1;
    }
}
?>

Using.php (Un ejemplo de cómo llamar a la 'subclase')

<?php
    require_once("User.php");

    //calling a subclass reference:
    echo "Value of user type Admin: ".User\Type::ADMIN;
?>

1
2017-08-22 16:20



Coloque cada clase en archivos separados y "requiérelos".

User.php

<?php

    class User {

        public $userid;
        public $username;
        private $password;
        public $profile;
        public $history;            

        public function __construct() {

            require_once('UserProfile.php');
            require_once('UserHistory.php');

            $this->profile = new UserProfile();
            $this->history = new UserHistory();

        }            

    }

?>

UserProfile.php

<?php

    class UserProfile 
    {
        // Some code here
    }

?>

UserHistory.php

<?php

    class UserHistory 
    {
        // Some code here
    }

?>

-1
2017-11-24 22:59