Factory Method: define an interface for creating objects, and let subclasses decide which class to instantiate. Factory Method delays the instantiation of a class to its subclasses.
Factory mode: generate different class instances according to different parameters.
Factory pattern is divided into simple factory pattern, factory method pattern and abstract factory pattern.
① Simple factory mode: create objects through static methods.
② Factory method mode: the static attribute of the method in the simple factory mode is removed, so that it can be inherited by the subclass, and an interface for creating the object is defined, so that the subclass decides which class to instantiate.
③ Abstract factory pattern: provides an interface to create a series of related or interdependent objects.
example:
Basic factory pattern (actually a simple class)
//Define a user class
class User
{
private $username;//Define a private variable
public function __construct($username)
{
$this->username = $username;
}
public function getUser()
{
return $this->username;
}
}
//User factory
class userFactory
{
static public function createUser()//Static method, which can be called without instantiation
{
//Instantiate User class in factory class
return new User('jack');
}
}
$user = userFactory::createUser();
echo $user->getUser();//jack
Simple factory mode: objects are created by static methods.
interface userProperties
{
function getUsername();
function getGender();
function getJob();
}
class User implements userProperties
{
private $username;
private $gender;
private $job;
public function __construct($username,$gender,$job)
{
$this->username = $username;
$this->gender = $gender;
$this->job = $job;
}
public function getUsername()
{
return $this->username;
}
public function getGender()
{
return $this->gender;
}
public function getJob()
{
return $this->job;
}
}
class userFactory
{
static public function createUser($properties = [])//Property, content
{
return new User($properties['username'],$properties['gender'],$properties['job']);
}
}
$employers = [
['username'=>'jack','gender'=>'male','job'=>'coder'],
['username'=>'Marry','gender'=>'female','job'=>'designer'],
];
$user = userFactory::createUser($employers[0]);
echo $user->getUsername();
Factory method mode: the static properties of methods in the simple factory mode are removed so that they can be inherited by subclasses, and an interface for creating objects is defined so that subclasses can decide which class to instantiate.
interface userProperties
{
function getUsername();
function getGender();
function getJob();
}
interface createUser
{
function create($properties);
}
// Implement user parameter class
class User implements userProperties
{
private $username;
private $gender;
private $job;
public function __construct($username,$gender,$job)
{
$this->username = $username;
$this->gender = $gender;
$this->job = $job;
}
public function getUsername()
{
return $this->username;
}
public function getGender()
{
return $this->gender;
}
public function getJob()
{
return $this->job;
}
}
//User factory
class userFactory
{
private $user;
public function __construct($properties = [])// Construct method, initialize user attribute, instantiate user object
{
$this->user = new User($properties['username'],$properties['gender'],$properties['job']);
}
public function getUser()
{
return $this->user;
}
}
//Implementation create user interface
class FactoryMan implements createUser
{
//Create method in user interface
function create($properties)
{
// Returns the instantiated user factory object
return new userFactory($properties);
}
}
class FactoryWoman implements createUser
{
function create($properties)
{
return new userFactory($properties);
}
}
class clientUser
{
static public function getClient($properties)
{
$fac = new FactoryMan;
$man = $fac->create($properties);
echo $man->getUser()->getUsername();
}
}
$employers = [
['username'=>'Gentleness is only for the right person','gender'=>'male','job'=>'coder'],
['username'=>'Marry','gender'=>'female','job'=>'designer'],
];
$user =clientUser::getClient($employers[0]);
Today is not over, cool