工厂模式是二十三中设计模式中最常用的一种模式之一,几乎所有开源的框架都有用到工厂模式。
工厂模式可以分为三种:简单工厂模式、工厂方法模式、抽象工厂模式。
其中,简单工厂模式并没有列入到二十三中设计模式中,应为其太简单了,而且违反了开闭原则。
工厂方法模式 与 抽象工厂模式都是简单工厂模式的延伸。
对于工厂模式,其最主要的作用就是定义对象返回!
就是另外再定义类来定义需要使用到的对象,而不再是在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();
// 从新给工厂对象分配对象
factory = new HuaweiFactory;
MobilePhone *huaWei = factory->manufacturePhone();
huaWei->description();
// 从新给工厂对象分配对象
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();
// 给工厂对象分配华为手机对象
factory = new HuaweiFactory;
MobilePhone *huaWei = factory->manufacturePhone();
NewMobilePhone *newHuaWei = factory->newManufacturePhone();
huaWei->description();
newHuaWei->newDescription();
// 给工厂对象分配苹果手机对象
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;
}
运行结果:
总结:
到了这里,貌似工厂模式中的三种用法也讲完,不知道观看此片博文的朋友有没有看懂呢?按一个方向去想,工厂模式就是生成对象返回的;这样想会不会明白一点呢。
一定要记住,开发中工厂模式是很常用的一种设计模式,必须要学会!
重在理解吧,先把代码搞懂了,在去看类图,两者想着结合,相信一定会看懂的。