工厂模式是二十三中设计模式中最常用的一种模式之一，几乎所有开源的框架都有用到工厂模式。
工厂模式可以分为三种：简单工厂模式、工厂方法模式、抽象工厂模式。
其中，简单工厂模式并没有列入到二十三中设计模式中，应为其太简单了，而且违反了开闭原则。
工厂方法模式 与 抽象工厂模式都是简单工厂模式的延伸。
对于工厂模式，其最主要的作用就是定义对象返回！
就是另外再定义类来定义需要使用到的对象，而不再是在main函数中定义对象。
通俗的讲就是分配对象返回（工厂模式就是用来生产对象的）。
简单工厂模式
简单工厂模式是三个工厂模式中最简单的，其生产可以集中到一个了类中进行分配对象，进行有效的管理。
举一个例子：
现在市面上有许多品牌的手机，假设小米、华为、苹果三个品牌的手机都是在同一个工厂里生产的，且都是同一时间进行生产，那么工厂就可以决定生产哪个品牌的手机了（想生产哪个品牌的手机就生产哪个品牌的手机），这样就是使用到了简单工厂模式的原理。
可以使用在任何需要new对象的项目中！
UNL类图：
小米、华为、苹果三个类都是继承自手机类，然后手机生产工厂类的实现又依赖于他们三个品牌手机类。
如果还是不懂的话，看下面代码你就会明白他是怎么使用的了。
下面看代码吧：
#include <iostream>
#include <Windows.h>
using namespace std;
// 三台手机的类型
enum PHONE_TYPE {
MIUI,
HUAWEI,
IPHONE
};
// 手机类
class MobilePhone {
public:
virtual void description() = 0; // 纯虚函数
};
// 小米手机类
class Miui : public MobilePhone {
public:
void description() { // 描述信息
cout << "小米手机" << endl;
}
};
// 华为手机类
class Huawei : public MobilePhone {
public:
void description() {
cout << "华为手机" << endl;
}
};
// 苹果手机类
class Iphone : public MobilePhone {
public:
void description() {
cout << "苹果手机" << endl;
}
};
// 手机生产工厂
class Factory {
public:
// 根据传入来的类型，进行对应的分配对象返回
MobilePhone *manufacturePhone(PHONE_TYPE type) {
switch (type) {
case MIUI:
return (new Miui()); // 生产小米手机（生成小米手机对象返回）
break;
case HUAWEI:
return (new Huawei()); // 生产华为手机（生成华为手机对象返回）
break;
case IPHONE:
return (new Iphone()); // 生产苹果手机（生成苹果手机对象返回）
break;
default:
return NULL; // 返回NULL
break;
}
}
};
int main(void) {
// 建立工厂对象
Factory *factory = new Factory;
// 工厂对象调用manufacturePhone方法给父类指针对象分配对象
MobilePhone *xiaoMi = factory->manufacturePhone(MIUI);
// 打印描述信息
xiaoMi->description();
MobilePhone * huaWei = factory->manufacturePhone(HUAWEI);
huaWei->description();
MobilePhone *iphone = factory->manufacturePhone(IPHONE);
iphone->description();
// 释放内存
delete factory;
delete xiaoMi;
delete huaWei;
delete iphone;
system("pause");
return 0;
}
运行结果：
简单工厂模式虽然简单明了，但是如果需要增加类的话，就得去修改生产手机工厂中类了，这就违反了开闭原则，所以衍生了工厂方法模式。
工厂方法模式
工厂方法模式，不再只是由一个手机生产的工厂生产手机了，而是每种品牌都有自己的生产工厂，也就是说简单工厂模式中的工厂类不再使用他了，而是使用它的子类进行各自的生产手机。
既你想生产什么手机就生产什么手机，完全不会涉及到其他手机厂商，如果有删除或者增加手机品牌，完全不需要去修改其他手机厂商的代码，这就很好的体现了开闭原则。
可以使用在任何需要new对象的项目中！
如下面的UML图：
此时手机生产工厂不再运作，而是交由他的子类们运作生产。
看代码就懂了：
#include <iostream>
#include <Windows.h>
using namespace std;
//enum PHONE_TYPE {
// MIUI,
// HUAWEI,
// IPHONE
//};
// 手机类
class MobilePhone {
public:
virtual void description() = 0; // 纯虚函数
};
// 小米手机类
class Miui : public MobilePhone {
public:
void description() { // 描述信息
cout << "小米手机" << endl;
}
};
// 华为手机类
class Huawei : public MobilePhone {
public:
void description() {
cout << "华为手机" << endl;
}
};
// 苹果手机类
class Iphone : public MobilePhone {
public:
void description() {
cout << "苹果手机" << endl;
}
};
// 手机生产工厂
class Factory {
public:
virtual MobilePhone *manufacturePhone() = 0; // 纯虚函数
};
// 小米手机生产工厂
class MiuiFactory : public Factory {
public:
// 生产小米手机（生成小米手机对象返回）
MobilePhone *manufacturePhone() {
return (new Miui());
}
};
// 华为手机生产工厂
class HuaweiFactory : public Factory {
public:
// 生产华为手机（生成华为手机对象返回）
MobilePhone* manufacturePhone() {
return (new Huawei());
}
};
// 苹果手机生产工厂
class IphoneFactory : public Factory {
public:
// 生产苹果手机（生成苹果手机对象返回）
MobilePhone* manufacturePhone() {
return (new Iphone());
}
};
int main(void) {
// 定义工厂指针对象
Factory *factory = new MiuiFactory;
// 工厂对象调用manufacturePhone方法给父类指针对象分配对象
MobilePhone *xiaoMi = factory->manufacturePhone();
// 打印描述信息
xiaoMi->description();
delete factory; // 释放第一个工厂的内存
// 从新给工厂对象分配对象
factory = new HuaweiFactory;
MobilePhone *huaWei = factory->manufacturePhone();
huaWei->description();
delete factory; // 释放第二个工厂的内存
// 从新给工厂对象分配对象
factory = new IphoneFactory;
MobilePhone *iphone = factory->manufacturePhone();
iphone->description();
// 释放内存
delete factory; // 释放第三个工厂的内存
delete xiaoMi;
delete huaWei;
delete iphone;
system("pause");
return 0;
}
运行结果：
抽象工厂模式
抽象工厂模式是工厂方法模式的升级版。
也就是说，抽象工厂模式他不再仅限于生产手机，他还可以生产电脑、音箱、电视机等等。它不再是局限于生产一种类型的生产工厂。
下面我们以上面的手机工厂为基础，在拓展出一个升级版的手机生产工厂，手机二代，毕竟手机也是需要更新换代的嘛。
请看UML类图：
跟工厂方法模式的类图差不多，就是多了一个升级版的手机类。
看代码就懂了：
#include <iostream>
#include <Windows.h>
using namespace std;
// 手机类
class MobilePhone {
public:
virtual void description() = 0; // 纯虚函数
};
// 小米手机类
class Miui : public MobilePhone {
public:
void description() { // 描述信息
cout << "小米手机" << endl;
}
};
// 华为手机类
class Huawei : public MobilePhone {
public:
void description() {
cout << "华为手机" << endl;
}
};
// 苹果手机类
class Iphone : public MobilePhone {
public:
void description() {
cout << "苹果手机" << endl;
}
};
// 升级版手机类
class NewMobilePhone {
public:
virtual void newDescription() = 0;
};
// 升级版小米手机类
class NewMiui : public NewMobilePhone {
public:
void newDescription() {
cout << "小米手机二代" << endl;
}
};
// 升级版华为手机类
class NewHuawei : public NewMobilePhone {
public:
void newDescription() {
cout << "华为手机二代" << endl;
}
};
// 升级版苹果手机类
class NewIphone : public NewMobilePhone {
public:
void newDescription() {
cout << "苹果手机二代" << endl;
}
};
// 手机生产工厂
class Factory {
public:
virtual MobilePhone *manufacturePhone() = 0; // 纯虚函数
virtual NewMobilePhone *newManufacturePhone() = 0; // 纯虚函数
};
// 小米手机生产工厂
class MiuiFactory : public Factory {
public:
// 生产小米手机（生成小米手机对象返回）
MobilePhone *manufacturePhone() {
return (new Miui());
}
// 生产升级版小米手机（生成小米手机二代对象返回）
NewMobilePhone *newManufacturePhone() {
return (new NewMiui());
}
};
// 华为手机生产工厂
class HuaweiFactory : public Factory {
public:
// 生产华为手机（生成华为手机对象返回）
MobilePhone *manufacturePhone() {
return (new Huawei());
}
// 生产升级版华为手机（生成华为手机二代对象返回）
NewMobilePhone *newManufacturePhone() {
return (new NewHuawei());
}
};
// 苹果手机生产工厂
class IphoneFactory : public Factory {
public:
// 生产苹果手机（生成苹果手机对象返回）
MobilePhone *manufacturePhone() {
return (new Iphone());
}
// 生产升级版苹果手机（生成苹果手机二代对象返回）
NewMobilePhone *newManufacturePhone() {
return (new NewIphone());
}
};
int main(void) {
// 定义工厂指针对象
Factory *factory = new MiuiFactory;
// 生产小米手机
MobilePhone *xiaoMi = factory->manufacturePhone();
// 生产小米手机二代
NewMobilePhone *newXiaoMi = factory->newManufacturePhone();
xiaoMi->description();
newXiaoMi->newDescription();
delete factory; // 释放第一个工厂的内存
// 给工厂对象分配华为手机对象
factory = new HuaweiFactory;
MobilePhone *huaWei = factory->manufacturePhone();
NewMobilePhone *newHuaWei = factory->newManufacturePhone();
huaWei->description();
newHuaWei->newDescription();
delete factory; // 释放第二个工厂的内存
// 给工厂对象分配苹果手机对象
factory = new IphoneFactory;
MobilePhone* iphone = factory->manufacturePhone();
NewMobilePhone* newIphone = factory->newManufacturePhone();
iphone->description();
newIphone->newDescription();
// 释放内存
delete factory; // 释放第三个工厂的内存
delete xiaoMi;
delete newXiaoMi;
delete huaWei;
delete newHuaWei;
delete iphone;
delete newIphone;
system("pause");
return 0;
}
运行结果：
总结：
到了这里，貌似工厂模式中的三种用法也讲完，不知道观看此片博文的朋友有没有看懂呢？按一个方向去想，工厂模式就是生成对象返回的；这样想会不会明白一点呢。
一定要记住，开发中工厂模式是很常用的一种设计模式，必须要学会！
重在理解吧，先把代码搞懂了，在去看类图，两者想着结合，相信一定会看懂的。
9万+
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
