In accordance with the concepts expressed in the beginning of this article, in this case I'm going to illustrate the implementation of the factory pattern by creating a couple of concrete factory classes, which will be responsible for spawning different types of data saving objects.

As you'll see shortly, the factory classes will be provided with the ability to return two specific kinds of objects to client code. The first kind will work in a predefined "string" context and the second kind will be used in an "object" environment.

The previous explanation probably seems a bit disembodied if I don't show you the corresponding definitions for these classes, so here they are: 

// define abstract 'DataSaverFactory' class
abstract class DataSaverFactory{
   abstract public function createDataSaver($type);
}

// define first concrete factory
class StringSaverFactory extends DataSaverFactory{
   private $context='string';
   public function createDataSaver($type){
     $dataSaver=NULL;
     switch($type){
       case "file";
         $dataSaver=new FileStringSaver();
         break;
       case "cookie";
         $dataSaver=new CookieStringSaver();
         break;
       default:
         $dataSaver=new FileStringSaver();
         break; 
     }
     return $dataSaver;
   }
}

// define second concrete factory
class ObjectSaverFactory extends DataSaverFactory{
   private $context='object';
   public function createDataSaver($type){
     $dataSaver=NULL;
     switch($type){
       case "file";
         $dataSaver=new FileObjectSaver();
         break;
       case "cookie";
         $dataSaver=new CookieObjectSaver();
         break;
       default:
         $dataSaver=new CookieObjectSaver();
         break; 
     }
     return $dataSaver;
   }
}

After examining the respective signatures of the above factory classes, things are a bit clearer to you, right? As you can see, the first concrete class has been conceived to work in a predefined "string" context. It is tasked with creating two concrete types of objects, which save data strings to different locations, including text files and cookies.

In a similar way, the second concrete factory class returns to client code objects whose primary task is to save other objects (not strings) to a specified file or cookie. Of course, due to the nature of the data with which this factory works, the class in question is designed to work in an "object" environment. Quite understandable, right?

All right, I think that at this point you already understand how the pair of factory classes defined previously do their business. So it's a good time to move forward and start defining the data saving classes that work in the predefined contexts I explained above. 

These brand new classes will be built in the course of the following section, therefore jump ahead and keep reading to learn more about them.