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 is very good when you are dealing with multiple resources and want to implement high level abstraction.

Let's break this into different section.

Suppose you have to implement abstraction and the user of your class doesn't need to care about what you've implemented in class definition. 

He/She just need to worry about the use of your class methods.

e.g. You have two databases for your project 

```
class MySQLConn {

        public function __construct() {
                echo "MySQL Database Connection" . PHP_EOL;
        }

        public function select() {
                echo "Your mysql select query execute here" . PHP_EOL;
        }

}

class OracleConn {

        public function __construct() {
                echo "Oracle Database Connection" . PHP_EOL;
        }

        public function select() {
                echo "Your oracle select query execute here" . PHP_EOL;
        }

}

```

Your Factory class would take care of the creation of object for database connection.

```
class DBFactory {

        public static function getConn($dbtype) {

                switch($dbtype) {
                        case "MySQL":
                                $dbobj = new MySQLConn();
                                break;
                        case "Oracle":
                                $dbobj = new OracleConn();
                                break;
                        default:
                                $dbobj = new MySQLConn();
                                break;
                }

                return $dbobj;
        }

}

```

User just need to pass the name of the database type

```
$dbconn1 = DBFactory::getConn("MySQL");
$dbconn1->select();

```

Output:

```
MySQL Database Connection
Your mysql select query execute here

```

In future you may have different database then you don't need to change the entire code only need to pass the new database type and other code will run without making any changes.

```
$dbconn2 = DBFactory::getConn("Oracle");
$dbconn2->select();

```

Output:

```
Oracle Database Connection
Your oracle select query execute here

```

Hope this will help.