永远不要在构造函数中实例化对象？

Question

像下面这样在构造函数中实例化对象是不是很糟糕？

class Foo
{
    public function fooMethod() {
        return 'foo method';
    } 
}

class Too
{
    public function tooMethod() {
        return 'too method';
    } 
}

class Boo
{
    public $foo;
    public $too;

    public function __construct()
    {
        $this->foo = new Foo();
        $this->too = new Too();
    }
}

如果是这样，它有多糟糕？应该怎么做才合适？

Answer 1

这取决于您的项目规模。

在大型项目或长期项目上，应该稍微改变一下。

理想情况下，你会重构它实现Dependency Injection pattern，并可能使用工厂来实例化它。

一些示例代码：

interface FooInterface { function fooMethod(); } 
class Foo implements FooInterface { function fooMethod(){return 'Foo';} }

interface TooInterface { function tooMethod(); } 
class Too implements FooInterface { function tooMethod(){return 'Too';} }

class Boo
{
    public $foo;
    public $too;

    public function __construct(FooInterface $foo, TooInterface $boo)
    {
        $this->foo = $foo;
        $this->too = $boo;
    }
}

class BooFactory
{
    public static function create()
    {
        return new Boo(new Foo, new Too);
    }
}

Answer 2

在另一个类中手动实例化类会创建隐式依赖项，这很难维护 - 如果您需要更改 Foo 和 Too 类，您将很难检测到需要更改的内容。

因此，管理依赖项的更好方法是：

class Foo
{
    private $_bar;

    function __construct(Bar $bar)
    {
         $this->_bar = $bar;
    }
}

这样，你的对象依赖是明确的。这样做的另一个好处是，一些 PHP 框架（Laravel、Zend、Symfony）允许自动解决依赖关系。这意味着，您不必手动实例化您的对象，而只能通过某种工厂 - 就像这样（Laravel）：

$foo = App::make('Foo');

App 工厂会使用一些反射魔法自动检测您的 Foo 类依赖项并适当地注入它们。其他框架也有类似的功能。

此外，OOP 中有一些通用原则，称为SOLID，它们有助于开发更好的 OOP 设计。其中之一 - D，代表 Dependency Inversion。这意味着，您应该避免 hard 依赖，就像在您的代码中一样。相反，Foo 和 Bar 类都应该依赖于 interface，如下所示：

interface BarInterface
{
    function doBar();
}

class Bar implements BarInterface
{
    function doBar()
    {
        print "Doing BAR";
    }
}

class Foo
{
    /**
     * @var BarInterface
     */
    private $bar;

    function __construct(BarInterface $bar)
    {

        $this->bar = $bar;
    }
}

现在，如果您需要用其他东西更改 Bar 类，如果您的替代品也实现了 BarInterface，那么一切都不会松懈。

Answer 3

这取决于您的要求和课程。 假设每次调用 Foo/Too 的构造函数时，您都会对数据库执行大量查询以获取数据，在这种情况下，我会选择使用 lazy instantiation。

当然，在构造函数上初始化你的属性是一个好习惯，但在现实生活中的表现可能是你的敌人。

例子：

class Boo {
   private $foo = null;
   private $too = null;
   public function __construct() {
      //Do something else
   }
   public function getFoo() {
      if (is_null($this->foo)) {
         $this->foo = new Foo();
      }
      return $this->foo;
   }
   public function getToo() {
      if (is_null($this->too)) {
         $this->too = new Too();
      }
      return $this->too;
   }
   public function aMethodThatUsesFoo() {
      $foo = $this->getFoo();
      $foo->fooMethod();
   }
   public function aMethodThatDoesntUsesFoo() {
      echo "Hello!, I don't need foo or too to execute this method";
   }
}

如果你只使用这个类来执行aMethodThatDoesntUsesFoo()，它永远不会调用Foo/Too的构造函数。

$boo = new Boo();
$boo->aMethodThatDoesntUsesFoo();

如果你只执行aMethodThatUsesFoo()，它只会实例化Foo

$boo = new Boo();
$boo->aMethodThatUsesFoo();

您也可以通过静态方法来做到这一点。

Answer 4

本质上并不坏。

缺点是它降低了你的类的“可测试性”，仅仅是因为Boo 现在依赖于Foo 和Too 的存在。