定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
类型：创建型模式
分类：
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
简单工厂模式
简单工厂模式也叫做叫做静态工厂方法(static Factory Method)模式。
特点：由一个工厂对象决定创建出来哪一种产品类的实例.
实质：由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。
两大组成部分:
- 一个抽象产品类，可以派生出多个具体产品类。
- 一个具体工厂类，可根据用户需要生产具体产品。
举例:
假设有一个工厂，能生产出A、B两种产品。当客户需要产品的时候需要告诉工厂哪种产品，是A还是B。当新增加一种新产品的时候，那么就要去修改工厂的类。
代码示例：
#include<iostream>
using namespace std;
class product //产品的抽象类
{
public:
virtual void show() = 0;
};
class productA : public product //产品A
{
public:
virtual void show() { cout << "productA\n"; }
};
class productB : public product //产品B
{
public:
virtual void show() { cout << "productB\n"; }
};
class factory //生产产品的工厂
{
public:
static product * createProduct(char ch)
{
switch (ch)
{
case 'A':
return new productA();
case 'B':
return new productB();
default:
return NULL;
}
}
};
int main()
{
factory *f= new factory();
product *p=f->createProduct('A');//指定生产产品A
p->show();
p = f->createProduct('B');//指定生产产品A
p->show();
return 0;
}
优点：无需新增产品工厂类
缺点：增加新的产品时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。
改进方法：工厂方法模式
工厂方法模式
特点：对每一个子类产品都分别对应一个工厂子类，用来创建相应的产品，这样若增加了新的产品，只需相应增加工厂子类即可
实质：定义一个用于创建对象的接口，让子类决定实例化哪一个类
两大组成部分：
- 一个抽象产品类，可以派生出多个具体产品类。
- 一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
举例：
现在有A、B两种产品，那么需要两个工厂。工厂A负责生产A产品，工厂B负责生产B种产品。这时候客户不需要告诉工厂产品名，而是告诉工厂生产就可以了。
比如：客户需要产品A，就直接告诉工厂A，让其生产。
代码示例：
#include<iostream>
using namespace std;
class product //产品的抽象类
{
public:
virtual void show() = 0;
};
class productA : public product //产品A
{
public:
virtual void show() { cout << "productA\n"; }
};
class productB : public product //产品B
{
public:
virtual void show() { cout << "productB\n"; }
};
class factory //工厂的抽象类
{
public:
virtual product * create() = 0;
};
class factoryA :public factory //具体的工厂A
{
public :
virtual product *create()
{
return new productA();
}
};
class factoryB :public factory//具体的工厂B
{
public:
virtual product *create()
{
return new productB();
}
};
int main()
{
factoryA *fa= new factoryA();
product *p=fa->create();//指定生产产品A
p->show();
factoryB *fb = new factoryB();
p = fb->create();//指定生产产品B
p->show();
return 0;
}
优点：不用修改已有代码，满足开放封闭原则。
缺点：每个工厂子类只能生产单一类型的产品，如果需要生产多种类型的产品，就无法满足。
改进方法：抽象工厂模式
抽象工厂模式
特点：向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象
实质：在一个具体的工厂类中聚合多个同类产品
两大组成部分：
- 抽象工厂：声明一个用于创建抽象产品的接口，可以派生创建具体产品的具体工厂
- 抽象产品：声明一个产品对象类型的接口，可以派生具体的产品类
举例：
我们A产品中有A1和A2两种型号的厂品，B产品中有B1和B2两种型号的厂品，上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设两家工厂，工厂A负责生产A1 、A2型号产品，B工厂负责生产B1、B2型号的产品。
代码示例：
#include<iostream>
using namespace std;
class product1//第1类产品的抽象类
{
public:
virtual void show() = 0;
};
class productA1 : public product1 //产品A1
{
public:
virtual void show() { cout << "productA1\n"; }
};
class productB1 : public product1//产品B1
{
public:
virtual void show() { cout << "productB1\n"; }
};
class product2 //第2类产品的抽象类
{
public:
virtual void show() = 0;
};
class productA2 :public product2//产品A2
{
public:
virtual void show()
{
cout << "productA2\n";
}
};
class productB2 :public product2//产品B2
{
public:
virtual void show()
{
cout << "productB2\n";
}
};
class factory //生产产品的工厂
{
public:
virtual product1 * create1() = 0;
virtual product2 * create2() = 0;
};
class factoryA :public factory //生产A类产品的具体工厂
{
public :
virtual product1 *create1()
{
return new productA1();
}
virtual product2 *create2()
{
return new productA2();
}
};
class factoryB :public factory//生产B类产品的工厂
{
public:
virtual product1 *create1()
{
return new productB1();
}
virtual product2 *create2()
{
return new productB2();
}
};
int main()
{
factoryA *fa= new factoryA();
product1 *p1=fa->create1();//指定生产产品A1
p1->show();
product2 *p2 = fa->create2();//指定生产产品A2
p2->show();
factoryB *fb = new factoryB();
p1= fb->create1();//指定生产产品B1
p1->show();
p2 = fb->create2();//指定生产产品B2
p2->show();
return 0;
}
优点：
- 封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂即可。
- 可以支持不同类型的产品，使得模式灵活性更强。
- 可以非常方便的使用一族中的不同类型的产品。
缺点：
- 结构过于臃肿，如果产品类型较多或产品族较多，会非常难于管理。
- 每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。