工厂模式
一个类可能在很多地方都需要实例化。比如数据库类，每次使用都需要实例化。如果类名改了，则相对调用位置的代码也需要修改。
因为类在实例化对象的时候，是用 new类名 实现的。如果类名修改，则所有的new 操作的确都需要重新修改代码。
如果有一种方式，集中所有的实例化。这样代码就只需要修改一次。那么代码的修改就变得简单了。这就是工厂模式设计的最初的设计想法。
核心思想就是：
1、实例化对象不用new ，而用工厂方法代替
2、将选择实现类和创建对象统一管理和控制。从而达到调用者和实现类解耦的目的。
工厂模式分类
简单工厂
用来生产同一结构中的任意产品（对新增加产品，需要修改原代码）工厂方法
用来生产同一结构产品（支持增加任意产品）抽象工厂
围绕一个超级工厂创建其他工厂，该超级工厂又称之为工厂的工厂。
工厂模式设计
定义 :工厂模式，顾名思义，就是像工厂流水线一样生成对象。由一个地方产生对象，其他地方就不需要额外的实例化。从而达到后期代码统一维护的目的。而且工厂模式可以方便因此真实结构，因此更加安全。从而实现创建者和调用者分离的目的。
特点：将调用者和创建者分离，调用者直接向工厂类请求获取调用对象，减少代码耦合，提高系统的维护性和扩展性
应用场景：有多个产品类时就要用到工厂模式，比如在数据库连接中，我们可以采用多种数据库连接方法，有mysql扩展，mysqli扩展，PDO扩展等，在这种情况下我们可以一个扩展对应一个产品类，然后采用工厂模式。
１．分两部分，产品类和工厂类，其中产品类有多个，而工厂类只有一个。
２．工厂类必须提供一个生产产品的方法。
工厂模式实现思路：
1、工厂模式是针对“相同模型”的产出。即，使用工厂模式产出的相应对象类都有相似的结构或者功能。所以，首先就需要一批具有相似功能的类（本质是大类下面的小类，比如人类下的男人，女人）。
//工厂模式
//1、需要使用的类1
class Man{
public function display(){
echo '这是男人';
}
}
//1、需要使用的类2
class Woman{
public function display(){
echo '这是女人';
}
}
//1、需要使用的类3
class Ladyboy{
public function display(){
echo '这是人妖';
}
}
2、以前访问这些类都需要new类名实现。为了集中实例化，我们引入了一个HumanFactory（人类工厂）类。用以专门对类进行实例化。
知识点： 类new 一个字符串，则是直接实例化字符串相同名的类。我们用变量代替字符串，就可以实现动态实例化类的效果。
由此我们的简单工厂模式，就设计完成。
简单工厂初始：
<?php
//工厂模式
//1、需要使用的类1
class Man{
public function display(){
echo '这是男人';
}
}
//1、需要使用的类2
class Woman{
public function display(){
echo '这是女人';
}
}
//1、需要使用的类3
class Ladyboy{
public function display(){
echo '这是人妖';
}
}
//2、工厂类 HumanFactory
class HumanFactory{
//工厂方法：专门产生类的对象
public function geyInstance($classname){
return new $classname;
}
}
// 使用公共
$hf = new HumanFactory();
//男人
$m = $hf->geyInstance('Man');
$m->display();
3、上述工厂类在对象生产的时候，额外产生了个工厂类的对象，实际上毫无意义。因此可以使用更优的方式来产生对象：静态工厂。
静态工厂
<?php
//静态工厂模式
//1、需要使用的类1
class Man{
static public function display(){
echo '这是男人';
}
}
//1、需要使用的类2
class Woman{
static public function display(){
echo '这是女人';
}
}
//1、需要使用的类3
class Ladyboy{
static public function display(){
echo '这是人妖';
}
}
//2、工厂类 HumanFactory
//3、静态工厂类
class HumanFactory{
//工厂方法：专门产生类的对象
static public function geyInstance($classname){
return new $classname;
}
}
//静态工厂使用
$m = HumanFactory::geyInstance('Man');
$m::display();
4、以上模式虽然是工厂生产对象，但是建立在提前知道类名的情况下的。如果类名修改，依然需要修改多处地方。没有达到工厂模式真正的目的，所以还需要改进。
为了解决类名必须知道的问题。我们可以内部封装对应工厂名，这个模式我们称之为：匿名工厂
匿名工厂
<?php
//静态工厂模式
//1、需要使用的类1
class Man{
static public function display(){
echo '这是男人';
}
}
//1、需要使用的类2
class Woman{
static public function display(){
echo '这是女人';
}
}
//1、需要使用的类3
class Ladyboy{
static public function display(){
echo '这是人妖';
}
}
//2、工厂类 HumanFactory
//3、匿名工厂类
class HumanFactory{
/**
* @param $flag 封装的标志名
*
*/
static public function geyInstance($flag){
switch ($flag){
case 'm':
return new Man();
case 'w':
return new Woman();
case 'l':
return new Ladyboy();
default:
return null;
}
}
}
//匿名工厂类使用
$m = HumanFactory::geyInstance('m');
$m::display();
知识点：return 是直接返回值，然后结束函数。可以不需要break
当类名被封装后，如何类被修改。则指修改new 的对应类名就可以了。而被调用的标志名可以不变。至此，我们想要达到的效果完成。
5、一般产品类就一个方法，由此我们可以增加个魔术方法，用自动调用增加代码效率。
静态工厂优化版
<?php
//静态工厂模式
//1、需要使用的类1
class Man{
public function __construct()
{
echo '这是男人';
}
}
//1、需要使用的类2
class Woman{
public function __construct()
{
echo '这是女人';
}
}
//1、需要使用的类3
class Ladyboy{
public function __construct()
{
echo '这是人妖';
}
}
//2、工厂类 HumanFactory
//3、匿名工厂类
class HumanFactory{
/**
* @param $flag 封装的标志名
*
*/
static public function geyInstance($flag){
switch ($flag){
case 'm':
return new Man();
case 'w':
return new Woman();
case 'l':
return new Ladyboy();
default:
return null;
}
}
}
//匿名工厂类使用
$m = HumanFactory::geyInstance('m');
6、为了给对应类约束，我们一般会在产品类之前添加一个接口。所以标准版的简单工厂。如下
标准简单工厂
<?php
interface FunctionFactory{
public function Human();
}
//静态工厂模式
//1、需要使用的类1
class Man implements FunctionFactory {
public function Human()
{
echo '这是男人';
}
public function __construct()
{
$this->Human();
}
}
//1、需要使用的类2
class Woman implements FunctionFactory{
public function Human()
{
echo '这是女人';
}
public function __construct()
{
$this->Human();
}
}
//1、需要使用的类3
class Ladyboy implements FunctionFactory{
public function Human()
{
echo '这是人妖';
}
public function __construct()
{
$this->Human();
}
}
//2、工厂类 HumanFactory
//3、匿名工厂类
class HumanFactory{
/**
* @param $flag 封装的标志名
*
*/
static public function geyInstance($flag){
switch ($flag){
case 'm':
return new Man();
case 'w':
return new Woman();
case 'l':
return new Ladyboy();
default:
return null;
}
}
}
//匿名工厂类使用
$m = HumanFactory::geyInstance('m');
总结：
1、简单工厂模式是一种按需生产对象的方式
2、简单工厂模式一般主要用在大型项目中，此种项目里面会出现很多相同的类，由此需要工厂模式产生对象。
3、简单工厂模式的优点在于后期维护（修改类名）
4、简单工厂模式的缺点在于，随着功能增加会增加开发量（开发多个工厂）
5、相对于工厂方法而言，代码更显轻量。时候小型项目使用。
工厂方法
简单工厂最大的问题在于，如果要添加新功能，就需要修改原类，原有方法。这对于代码的灵活支持不友好。不符合设计模式的开闭原则。严格来讲，简单工厂不是一个真正的设计模式。
为了实现代码的扩展，我们把各个类给分别创建工厂。实现调用对应工厂就可以了了。
工厂方法模式
<?php
//抽象工厂 依旧上简单工厂 创建工厂的类
interface Car{
public function name();
}
//工厂方法模式
// 具体工厂 1 宝马
class BMW implements Car {
public function name()
{
// 100行初始化代码
echo '宝马';
}
public function __construct()
{
$this->name();
}
}
// 具体工厂2 奔驰
class Benz implements Car{
public function name()
{
// 100行初始化代码
echo '奔驰';
}
public function __construct()
{
$this->name();
}
}
// 具体工厂3 比亚迪
class BYD implements Car{
public function name()
{
// 100行初始化代码
echo '比亚迪';
}
public function __construct()
{
$this->name();
}
}
//与上面简单工厂模式对比。这里本质区别在于，此处是将对象的创建抽象成一个接口。（也就是把匿名工厂类替换成了产品接口）
// 抽象产品 创建实现产品的接口 ; 需要使用时 提供对应的产品接口 就完成了实现; 从而达到了 去 if else 目的
interface CarFactory{
static public function getCar();
}
// 具体产品1 宝马
class BWMFactory implements CarFactory{
static public function getCar()
{
// TODO: Implement getCar() method.
return new BMW();
}
}
//具体产品 2 奔驰
class BenzFactory implements CarFactory{
static public function getCar()
{
// TODO: Implement getCar() method.
return new Benz();
}
}
// 具体产品2 比亚迪
class BYDFactory implements CarFactory{
static public function getCar()
{
// TODO: Implement getCar() method.
return new BYD();
}
}
// ===========================新增工厂 场景 ====================================
//新增法拉利 工厂
class Ferrari implements Car{
public function name()
{
echo '法拉利';
}
public function __construct()
{
$this->name();
}
}
// 新增法拉利工厂方法
class FerrariFactory implements CarFactory{
static public function getCar()
{
// TODO: Implement getCar() method.
return new Ferrari();
}
}
// ================= 执行场景 =========================
// 使用奔驰
BenzFactory::getCar();
// 使用法拉利
FerrariFactory::getCar();
总结
1、工厂方法，在原来简单工厂的层面上降低了耦合，增加了可扩展性
2、但工厂方法相对简单来说，代码复杂度增加，编程复杂度也增加。
3、由于上面特点，工厂方法，更适合用在更为复杂的大中型项目中。
抽象工厂
抽象工厂，就是在原来产品工厂类的基础上，再增加个工厂的分发工厂类(也就是所谓超级工厂)。实现工厂的工厂目的。
抽象工厂模式的组成
抽象工厂（AbstractFactory）：确定工厂的业务范围。
具体工厂（ConcreteFactory）：每个具体工厂对应一个产品族。具体工厂决定生产哪个具体产品对象。
抽象产品（AbstractProduct）：同一产品等级结构的抽象类。
具体产品（ConcreteProduct）：可供生产的具体产品。
抽象工厂实现
产品类
//产品类 增加不同种类（汽车，空调）的不同产品（【奔驰、奥迪】【格力、海尔】）
// 汽车（抽象产品接口）
interface AutoProduct
{
public function dirve();
}
//奥迪A4（具体产品类）
class AudiA4Product implements AutoProduct
{
//获取汽车名称
public function dirve()
{
// 100行初始化代码
echo "开奥迪A4"."<br>";
}
}
//奔驰C200（具体产品类）
class BenzC200Product implements AutoProduct
{
//获取汽车名称
public function dirve()
{
// 100行初始化代码
echo "开奔驰C200"."<br>";
}
}
//空调（抽象产品接口）
interface AirCondition
{
public function blow();
}
//格力空调某型号（具体产品类）
class GreeAirCondition implements AirCondition
{
public function blow()
{
echo "吹格力空调某型号"."<br>";
}
}
//海尔空调某型号（具体产品类）
class HaierAirCondition implements AirCondition
{
public function blow()
{
echo "吹海尔空调某型号"."<br>";
}
}
工厂类
//工厂接口
//定义车的功能，能开，能吹空调
interface Factory
{
public function getAuto();
public function getAirCondition();
}
//实现 具体 产品族的组合
//工厂A = 奥迪A4 + 海尔空调某型号
class AFactory implements Factory
{
//汽车
public function getAuto()
{
return new AudiA4Product();
}
//空调
public function getAirCondition()
{
return new HaierAirCondition();
}
}
//工厂B = 奔驰C200 + 格力空调某型号
class BFactory implements Factory
{
//汽车
public function getAuto()
{
return new BenzC200Product();
}
//空调
public function getAirCondition()
{
return new GreeAirCondition();
}
}
客户端类
<?php
//客户端测试代码
//A工厂制作车
$factoryA = new AFactory();
$auto_carA = $factoryA->getAuto();
$auto_airA = $factoryA->getAirCondition();
//B工厂制作车
$factoryB = new BFactory();
$auto_carB = $factoryB->getAuto();
$auto_airB = $factoryB->getAirCondition();
//开奥迪车+吹海尔空调
$auto_carA->dirve();
$auto_airA->blow(); //热的时候可以吹吹空调
//奔驰C200 + 格力空调某型号
$auto_carB->dirve();
$auto_airB->blow(); //热的时候可以吹吹空调
