example - Clase anidada o interna en PHP

php class example

Question

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

Sé que C ++ , Java e incluso Ruby (y probablemente otros lenguajes de programación) permiten clases anidadas / internas dentro de la clase principal, lo 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?

Answer 1

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 relacionarla e incrustarla en esa clase y mantener las dos juntas.

• Aumenta la encapsulación.

Considere dos clases de nivel superior, A y B, donde B necesita acceso a los miembros de A que, de lo contrario, serían declarados privados. Al ocultar la clase B dentro de la clase A, los miembros de A pueden declararse privados y B puede acceder a 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

Puede tener un comportamiento similar 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.

Answer 2

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
}
?>

Answer 3

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;
?>

Answer 4

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";

Answer 5

Está esperando la votación como RFC https://wiki.php.net/rfc/anonymous_classes

Answer 6

Las clases reales anidadas con accesibilidad public / protected / private se propusieron en 2013 para PHP 5.6 como RFC pero no lo hicieron (No hay votación aún, no hay actualizaciones desde 2013 - a partir del 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.

Answer 7

No puedes hacer esto en PHP. Sin embargo, hay formas funcionales de lograr esto.

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

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

Answer 8

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 "Espacios de nombres", una terrible / sintaxis / hackeada / en / top / de PHP OOP: http://www.php.net/manual/en/language.namespaces.rationale.php

Answer 9

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:

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

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

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 agrega un método como este a la clase de User :

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 sus únicas llamadas a $this->profile sean del método __construct() (o del método en el que esté definido $this->profile ) 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.