php - Never instantiate objects in the constructor?

Solution:

Manually instantiating classes inside another class creates implicit dependencies, which are quite hard to maintain - you will have a hard time detecting what needs to be changed if you ever need to change thoseFoo andToo classes.

So, a better way of managing dependencies is:

class Foo
{
    private $_bar;

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

This way, your object dependency is explicit. Another advantage of doing this, is that some PHP frameworks, (Laravel, Zend, Symfony), allow for an automatic dependency resolution. It means, that you don't instantiate your object manually, only via some sort of factory - like this (Laravel):

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

And anApp factory automatically detects yourFoo class dependencies with some reflection magic and injects them appropriately. Other frameworks have similar capabilities, too.

Also, there are some general principles in OOP, calledSOLID which help to develop better OOP design. One of them -D, stands forDependency Inversion. What it means, is that you should avoidhard dependencies, like in your code. Instead, bothFoo andBar classes should depend on aninterface, like this:

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;
    }
}
Copy code

Now, if you ever need to change thatBar class with something else, all hell won't break loose, if your replacement also implements thatBarInterface.

Solution:

It's not inherently bad.

The downside is that it decreases the "testability" of your class, simply becauseBoo is now dependent on the existenceFoo andToo.

Solution:

This depends on the size of your project.

On large projects, or long term projects, it should be changed slightly.

Ideally, you would refactor it implement Dependency Injection pattern, and maybe use a Factory to instantiate it.

Some sample code:

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);
    }
}
Copy code

Solution:

It depends of your requirement and the classes. Let's says that every call to the constructor of Foo/Too you will execute a huge query to the database to get data, in that scenario I would opt to use lazy instantiation.

Of course, it's a good practice to initialize your properties on the constructor, but on real life performance could your enemy.

Example:

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";
   }
}
Copy code

if you use this class only to executeaMethodThatDoesntUsesFoo(), it will never call the constructors of Foo/Too.

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

if you will only executeaMethodThatUsesFoo(), it will only instantiateFoo

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

You can do this by static methods as well.