我正在为我的新网站构建一个用户类，不过这一次我想稍微有些不同...
C++、Java 甚至Ruby（以及可能的其他编程语言）都允许在主类中使用嵌套/内部类，这使得我们可以使代码更面向对象和有组织。
在 PHP 中，我想要做如下操作：
<?php
public class User {
public $userid;
public $username;
private $password;
public class UserProfile {
// some code here
}
private class UserHistory {
// some code here
}
}
?>
在PHP中是否可能实现？我该如何做到？
更新
如果不可能，未来的PHP版本是否会支持嵌套类？
嵌套类与外部类的关系略有不同。以Java为例：
非静态嵌套类可以访问封闭类的其他成员，即使它们被声明为私有。此外，非静态嵌套类需要实例化父类的实例。
OuterClass outerObj = new OuterClass(arguments);
outerObj.InnerClass innerObj = outerObj.new InnerClass(arguments);
使用嵌套类有几个令人信服的理由：
如果一个类只对另一个类有用，则将其与该类相关联并嵌入该类中并将两者保持在一起是合乎逻辑的。
考虑两个顶级类A和B，其中B需要访问A的成员，否则这些成员将被声明为私有。通过将类B隐藏在类A中，可以声明A的成员为私有，并且B可以访问它们。此外，B本身也可以被隐藏在外部世界之外。
嵌套类通常与其父类相关，并一起形成一个“包”。
即使没有嵌套类，您也可以在PHP中实现类似的行为。
如果你想要的只是结构/组织，例如Package.OuterClass.InnerClass，PHP命名空间可能足够使用。您甚至可以在同一文件中声明多个命名空间（尽管由于标准自动加载功能，这可能不可取）。
namespace;
class OuterClass {}
namespace OuterClass;
class InnerClass {}
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()");
}
}
}
}
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();
}
}
}
$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)
输出：
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
我真的不认为在PHP中尝试模拟内部类是一个好主意。我认为代码不够清晰易读。此外，可能有其他方法可以使用已经成熟的模式（如观察者、装饰器或组合）来实现类似的结果。有时，甚至简单的继承就足够了。
在2013年，PHP 5.6提出了具有public/protected/private可访问性的真正嵌套类作为RFC，但未能通过（截至2021/02/03，尚未进行投票，自2013年以来没有更新）：
https://wiki.php.net/rfc/nested_classes
class foo {
public class bar {
}
}
至少，匿名类已经被引入到PHP 7中
https://www.php.net/manual/en/language.oop5.anonymous.php https://wiki.php.net/rfc/anonymous_classes
从这个RFC页面：
未来范围
此补丁所做的更改意味着命名嵌套类更容易实现（略微）。
因此，我们可能会在某个未来版本中获得嵌套类，但尚未决定。
Parse error: syntax error, unexpected 'class' (T_CLASS), expecting function (T_FUNCTION) or const (T_CONST) in C:\xampp\htdocs\fastAuth\Fast-Auth\class.FastAuth.php on line 5。 - Shubham Gupta在 PHP 中，您无法这样做。但是，有功能性的方法可以实现此目标。
有关更多详细信息，请查看此帖子： 如何在 PHP 中创建嵌套类或嵌套方法？
这种实现方式称为流畅接口：http://en.wikipedia.org/wiki/Fluent_interface
<?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
}
}
}
?>
然而，这也带来了一个非常严重的警告。如果您使用像PHPStorm或NetBeans这样的IDE，并且将像这样的方法添加到User类中：
public function foo() {
$this->profile->...
}
再见自动完成。即使您使用接口编码（SOLID中的I），也是如此，使用类似这样的模式：
<?php
public class User {
public $profile;
public function __construct() {
$this->profile = new class implements UserProfileInterface {
// Some code here for user profile
}
}
}
?>
$this->profile 的方法是来自 __construct（）方法（或任何定义 $this->profile 的方法），否则您将不会得到任何类型提示。 您的属性本质上对您的IDE“隐藏”，如果您依赖IDE进行自动完成、代码嗅探和重构，则会让生活变得非常困难。public UserProfileInterface $profile;）来恢复自动补全。 - Shayan Toqraeeclass 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";
我认为使用命名空间解决这个问题是一种优雅的方法。在我的情况下，内部类不需要知道它的父类（就像Java中的静态内部类）。例如，我创建了一个名为“User”的类和一个名为“Type”的子类，用作示例中用户类型（ADMIN、OTHERS）的引用。祝好。
User.php（User类文件）
<?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（调用“子类”的示例）
<?php
require_once("User.php");
//calling a subclass reference:
echo "Value of user type Admin: ".User\Type::ADMIN;
?>
class Factory {
/**
* Method to manufacture an inner-class object.
*
* @param string $args Arguments to be passed to
* the inner-class constructor.
*/
static function manufacture_object($args) {
/**
* Here's the definition of the inner-class.
*/
return new class($args) {
static $remembers = 'Nothing';
private $args;
function __construct($args) {
$this->$args = $args;
}
function says() {
return $this->args;
}
};
}
}
/**
* Create an inner-class object and have it do its thing.
*/
$mort = Factory::manufacture_object("Hello World!");
echo $mort->says(); // Echoes "Hello World!"
$mort = Factory::manufacture_object("I can remember that.");
$mort2 = Factory::manufacture_object("I'll live vicariously through you.");
$mort::$remembers = 'Something';
echo $mort2::$remembers; // Echoes "Something"
在 PHP 7 中，您可以这样做：
class User{
public $id;
public $name;
public $password;
public $Profile;
public $History; /* (optional declaration, if it isn't public) */
public function __construct($id,$name,$password){
$this->id=$id;
$this->name=$name;
$this->password=$password;
$this->Profile=(object)[
'get'=>function(){
return 'Name: '.$this->name.''.(($this->History->get)());
}
];
$this->History=(object)[
'get'=>function(){
return ' History: '.(($this->History->track)());
}
,'track'=>function(){
return (lcg_value()>0.5?'good':'bad');
}
];
}
}
echo ((new User(0,'Lior','nyh'))->Profile->get)();
new class{} 而不是我在这里写的方式 (object)[];，对我来说实际上无法正常工作，尤其在 PHP 版本 7.1.33 中更是如此。如果我尝试该解决方案，并放入任何方法并调用它，则出错输出为：'PHP parse error: syntax error, unexpected "[function name (get)]" ..expecting function (T_FUNCTION) or const (T_CONSTANT) in (path) on line (line #)
function get(){...}，错误仍然存在。'PHP Fatal Error: Uncaught Error: function name must be a string' in (path):(Line #)
对于最顶层的解决方案，虽然在引用'inner'类时像嵌套一样，但代码实际上并没有将内部类嵌套在外部类中。
此外，您可以采用这种范例并进行扩展，创建任意深度的内部类层次结构：
class Inner_Inner_Inner_Inner_class_demonstrator{
public function __construct(){
$this->Writing=(object)[
'Files'=>(object)[
'Third_Level_Inner_Class'=>(object)[
'Fourth_Level_Inner_Class'=>(object)[
'write'=>function($_what,$_where,$_append){
$Handle;
if(!$_append)$Handle = fopen($_where, 'w');
else $Handle = fopen($_where, 'a');
fwrite($Handle, $_what);
fclose($Handle);
}
]
]
]
];
}
}
((new Inner_Inner_Inner_Inner_class_demonstrator())->Writing->Files->Third_Level_Inner_Class->Fourth_Level_Inner_Class->write)('four levels of inner classes!','tester.html',true);
User，例如：public class UserProfile extends User和public class UserHistory extends User。 - Dave Chen