PHP中的嵌套或内部类


111

我正在建立一个 为新网站用户类,但是这次我在考虑构建它有点不同...

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版本是否可能支持嵌套类?


4
这在PHP中是不可能的
尤金

您可以扩展它User,例如:public class UserProfile extends Userpublic class UserHestory extends User
Dave Chen

您也可以从抽象用户类开始,然后对其进行扩展。php.net/manual/en/language.oop5.abstract.php
马修·

@DaveChen我熟悉延伸。然而我在寻找一个更好的解决方案OOP类:( THX。
利奥尔Elrom

4
扩展与包容是不同的...扩展时,您将获得3类User类的重复(作为用户,作为UserProfile和作为UserHistory)
Tomer W

Answers:


136

介绍:

嵌套类与其他类的关系与外部类略有不同。以Java为例:

非静态嵌套类可以访问封闭类的其他成员,即使它们被声明为私有的也是如此。同样,非静态嵌套类要求实例化父类的实例。

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

使用它们有几个令人信服的原因:

  • 这是一种对仅在一个地方使用的类进行逻辑分组的方法。

如果一个类仅对其他一个类有用,那么将其关联并嵌入该类并将两者保持在一起是合乎逻辑的。

  • 它增加了封装。

考虑两个顶级类A和B,其中B需要访问A的成员,否则将其声明为私有。通过将类B隐藏在类A中,可以将A的成员声明为私有,而B可以访问它们。另外,B本身可以对外界隐藏。

  • 嵌套类可以导致更具可读性和可维护性的代码。

嵌套类通常与其父类相关,并一起形成一个“包”

在PHP中

如果没有嵌套类,则可以在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中模拟innerClasses是一个好主意。我认为代码不太干净和易读。同样,可能还有其他方法可以使用完善的模式来获得相似的结果,例如观察者,装饰或合并模式。有时,即使是简单的继承也已足够。


2
真棒@Tivie!我要将该解决方案实施到我的OOP扩展框架中!(参见我的github:github.com/SparK-Cruz)
SparK

21

真正的嵌套类与public/ protected/ private无障碍于2013年(自2013年以来没有投票到目前为止,还没有更新-提出了PHP 5.6作为RFC,但没能为2016年12月29日):

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

class foo {
    public class bar {
 
    }
}

至少,匿名类已将其纳入PHP 7

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

在此RFC页面中:

未来范围

此补丁所做的更改意味着命名嵌套类更易于实现(一点点实现)。

因此,我们可能会在将来的版本中获得嵌套类,但尚未决定。



5

从PHP 5.4版开始,您可以通过反射强制使用私有构造函数创建对象。它可以用来模拟Java嵌套类。示例代码:

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

4

根据Xenon对AnılÖzselgin的回答的评论,匿名类已在PHP 7.0中实现,与您现在所获得的嵌套类一样,它非常接近嵌套类。以下是相关的RFC:

嵌套类(状态:已撤销)

匿名类(状态:在PHP 7.0中实现)

原始帖子的一个示例,您的代码如下所示:

<?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之User类的IDE,然后将这样的方法添加到类中:

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进行自动补全,嗅探代码和重构,将使工作变得非常艰难。


3

您无法在PHP中做到这一点。PHP支持“ include”,但是您甚至不能在类定义中做到这一点。这里没有很多很棒的选择。

这并不能直接回答您的问题,但是您可能会对“名称空间”感兴趣,这是PHP OOP的一个非常丑陋的\语法\ hacked \ on \ top \:http//www.php.net/manual/zh/language .namespaces.rationale.php


命名空间当然可以更好地组织代码,但是它不如嵌套类强大。感谢你的回答!
Lior Elrom

你为什么称它为“可怕”?我认为可以,并且可以与其他语法环境很好地分开。
emfi '18 -4-11


2

我想我通过使用命名空间为这个问题写了一个优雅的解决方案。就我而言,内部类不需要知道其父类(就像Java中的静态内部类一样)。作为示例,我创建了一个名为“ User”的类和一个名为“ Type”的子类,在我的示例中用作用户类型(ADMIN,OTHERS)的引用。问候。

User.php(用户类文件)

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

2

您可以像这样在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->name=$name;
    $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)();

-6

将每个类放入单独的文件中并“要求”它们。

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
    }

?>
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.