Question: This confuses me, in the most simplest terms what does it do? Pretend you are explaining to your mother or someone almost please.

Answer: 
A factory creates an object. So, if you wanted to build

```
 class A{
    public $classb;
    public $classc;
    public function __construct($classb, $classc)
    {
         $this->classb = $classb;
         $this->classc = $classc;
    }
  }

```

You wouldn't want to rely on having to do the following code everytime you create the object

```
$obj = new ClassA(new ClassB, new Class C);

```

That is where the factory would come in. We define a factory to take care of that for us:

```
class Factory{
    public function build()
    {
        $classc = $this->buildC();
        $classb = $this->buildB();
        return $this->buildA($classb, $classc);

    }

    public function buildA($classb, $classc)
    {
        return new ClassA($classb, $classc);
    }

    public function buildB()
    {
        return new ClassB;
    }

    public function buildC()
    {
        return new ClassC;
    }
}

```

Now all we have to do is

```
$factory = new Factory;
$obj     = $factory->build();

```

The real advantage is when you want to change the class. Lets say we wanted to pass in a different ClassC:

```
class Factory_New extends Factory{
    public function buildC(){
        return new ClassD;
    }
}

```

or a new ClassB:

```
class Factory_New2 extends Factory{
    public function buildB(){
        return new ClassE;
    }
}

```

Now we can use inheritance to easily modify how the class is created, to put in a different set of classes. 

A good example might be this user class:

```
class User{
    public $data;
    public function __construct($data)
    {
        $this->data = $data;
    }
}

```

In this class `$data` is the class we use to store our data. Now for this class, lets say we use a Session to store our data. The factory would look like this:

```
class Factory{
    public function build()
    {
        $data = $this->buildData();
        return $this->buildUser($data);
    }

    public function buildData()
    {
        return SessionObject();
    }

    public function buildUser($data)
    {
        return User($data);
    }
}

```

Now, lets say instead we want to store all of our data in the database, it is really simple to change it:

```
class Factory_New extends Factory{
    public function buildData()
    {
        return DatabaseObject();
    }
}

```

Factories are a design pattern we use to control how we put objects together, and using correct factory patterns allows us to create the customized objects we need.
Factory Design Pattern (Factory Pattern) is for loose coupling. Like the meaning of factory, data to a factory (produce data) to final user. By this way, the factory break the tight coupling between source of data and process of data.