首页 > 代码库 > 设计模式学习(1) --- 3类工厂模式
设计模式学习(1) --- 3类工厂模式
讲个故事吧。从前一个老板非常有钱，非常喜欢数码产品手机，经常喜欢买智能手机，那么怎么买？当然，可以自己去各个手机店买，比如去苹果店，三星店买。但是老板是非常忙的，怎么办？老板是程序员出生。面向对象嘛。加个层次，叫秘书去买，把要买的型号，写张纸条给秘书即可。为什么这样做，对老板来说当然省事了，直接窃取秘书的劳动成果即可(因为付薪水了嘛）。秘书根据老板的指示去做，要买什么牌子手机就去相应的专卖店买即可。OK，这样应付了一段时间，因为这个时期智能手机刚刚兴起，也就几家可以做。
时光飞逝，岁月如梭。随着科技的进步，智能手机市场太大，至于处于一个智能手机的元年，用某人的话说“风口上，猪都能飞起来”。所以，一大批智能手机厂商出现，一大批智能手机品牌出现，但是这个老板从喜欢买智能手机到喜欢收集研究智能手机了，因为土豪嘛，不差钱。所以知道哪里又出款手机了，就叫秘书去买，天啊。这下可忙坏了秘书，要知道，世上的智能手机品牌这么多，秘书的工作现在负担变得更重了，不光要负责公司各种会议，还要天天出去买手机，心里甚是不爽。当然，老板看在眼里，就加了秘书的工资，并且给秘书配了几个同事协助秘书买智能手机这件事。秘书加薪了又有同事一起来分担，秘书这下爽了，这是要升职加薪充当CEO迎娶高富帅的节奏啊，顿时高兴起来了。而且秘书又是总管。老板要买什么新品牌手机，都是跟秘书先说，然后秘书在去分配其他同事分头去买。当然为此老板需要多些人工费，土豪嘛，这能有几个钱。ok这样又过了一段时间。
时间飞逝，岁月如梭。随着各大手机厂商的产品迭代，尼玛iphone都出到了6了。老板收集起来更加疯狂了，要把所有品牌的所有型号都买回来研究。这下又忙坏了秘书，因为秘书要搞清楚哪些个品牌都产到几代了，这当然也不是什么太大的难事，百度一下嘛，ok,在了解了各个品牌的系类产品后，再吩咐其他同事分别去买各个系列产品。当然如果产品品类太多，再增加个同事嘛。多付几个人力费而已。
最后土豪老板就这样将所有智能手机体验了个遍，都觉得不行，没有抓住消费者发烧心里，于是打算自己干一款产品，于是安静的创建了一家公司，势必要打造一款全球级别的重量级智能手机...美好的事情即将发生....那么问题来了，使用设计模式哪家强？
1.简单工厂模式(simple factory)
OK，小学语文老师教会了我们在分析语文课文时，按照自然段来划分中心思想。在第一段自然中程序员老板成分利用了自己所学的专长，将实际买手机问题，变成了面向对象问题（面向秘书哇！好幸福）。秘书具有按照老板要求买手机的功能。这个秘书就是工厂了（神马秘书是工厂？）抽象为工厂啦！专门做一间买各种品牌手机的事。而对于手机而言，需不需要抽象？各大手机厂商，也不太可能造芯片，屏幕等配件，所以也是个具有技术含量的零配件组装厂，所以可以具体抽象出行为（具有发短信，打电话，上网等功能的设备），各个实际手机厂商按照各自设计来设计。于是java代码如下：
//抽象类实现
abstract class phone
{ //抽象类至少一个抽象方法 这样才是抽象类
abstract void phoneInf();
}
//具体产品
class iphone extends phone
{
public void phoneInf()
{
System.out.println("Buy iphone");
}
}
class XiaoMi extends phone
{
public void phoneInf()
{
System.out.println("Buy XiaoMi");
}
}
//工厂
class Secretary
{
public static phone BuyPhone(String brand)
{
if(brand.equals("iphone") )
return new iphone();
else
{
if( brand.equals("XiaoMi") )
return new XiaoMi();
else
return null;
}
}
}
class Main
{
public static void main(String[] args)
{ //老板只需要告诉秘书买什么牌子的手机即可
phone p1 = Secretary.BuyPhone("XiaoMi");
p1.phoneInf();
phone p2 = Secretary.BuyPhone("iphone");
p2.phoneInf();
}
}/************************************************************************/
/* C++实现 简单工厂模式
*/
/************************************************************************/
#include <iostream>
#include <string>
using namespace std;
class Phone
{
public :
virtual void phoneInf() =0; //纯虚函数
};
class iPhone : public Phone
{
public:
void phoneInf()
{
cout<<"Buy iPhone"<<endl;
}
};
class XiaoMi : public Phone
{
public :
void phoneInf()
{
cout<<"Buy XiaoMi"<<endl;
}
};
class Secretary
{
public:
static Phone* BuyPhone(string brand)
{
if(brand == "iPhone")
return new iPhone();
else
{
if(brand == "XiaoMi")
return new XiaoMi();
else
return NULL;
}
}
};
int main()
{
Phone* p1 = Secretary::BuyPhone("iPhone");
p1->phoneInf();
Phone* p2 = Secretary::BuyPhone("XiaoMi");
p2->phoneInf();
return 0;
}从上可见简单工厂模式组成：
a.工厂类（这里是秘书），核心部分。由一个具体的类实现。
b.抽象产品。 （这里是phone），java中由一个接口或者抽象类实现。C++中可以由抽象类(含有纯虚函数的类）实现。
C.具体产品。这里指的是各个手机厂商产生的产品，比如iphone,xiaomi等。java中继承或者实现 抽象类和接口，完成实际产品实例的创建。C++中子类实例化对象。
这样做，老板（实际客户）只提出请求，执行全部将由秘书（工厂类）来做。其中工厂类必须具有逻辑判断等一些功能，比如秘书要能分辨各种手机品牌的功能。这样子，数据量小时候，完全可以这么做。一旦老板需要有些新手机，但是数据量较小时候，秘书就需要在买一些品牌了（对于工厂类而言，就是需要在修改类了）。
2.工厂方法模式(factory method)
第二自然段告诉我们，当秘书实在忙不过来了，频繁的修改工厂类，相当于导致秘书工作量巨大，必须有人来帮忙才行。这下秘书只管负责安排任务，具体的手机叫手下买了，再给秘书即可。这时候，需要增加一个抽象工厂类，用于只分发任务功能，具体的工作由实际工厂来做。代码如下：
//java 工厂方法模式
//抽象产品
abstract class phone
{
public abstract void phoneInf();
}
//具体产品
class iphone extends phone
{
public void phoneInf()
{
System.out.println("Buy iphone");
}
}
class XiaoMi extends phone
{
public void phoneInf()
{
System.out.println("Buy XiaoMi");
}
}
//抽象工厂类
abstract class Secretary
{
public abstract phone BuyPhone();
}
//实际工厂类
class PersonA_iphone extends Secretary
{
public phone BuyPhone()
{
return new iphone();
}
}
class PersonB_XiaoMi extends Secretary
{
public phone BuyPhone()
{
return new XiaoMi();
}
}
class Main
{
public static void main(String[] args)
{
//秘书分配person1去买iphone
PersonA_iphone person1 = new PersonA_iphone() ;
phone p1 = person1.BuyPhone();
p1.phoneInf();
//秘书分配person2去买XiaoMi
PersonB_XiaoMi person2 = new PersonB_XiaoMi();
phone p2 = person2.BuyPhone();
p2.phoneInf();
}
}/************************************************************************
C++实现 工厂方法模式
************************************************************************/
#include <iostream>
#include <string>
using namespace std;
class Phone
{
public :
virtual void phoneInf() =0; //纯虚函数
};
class iPhone : public Phone
{
public:
void phoneInf()
{
cout<<"Buy iPhone"<<endl;
}
};
class XiaoMi : public Phone
{
public :
void phoneInf()
{
cout<<"Buy XiaoMi"<<endl;
}
};
//抽象工厂
class Secretary
{
public:
virtual Phone* BuyPhone()= 0 ;
};
//实际工厂
class PersonA_iphone : public Secretary
{
public:
Phone* BuyPhone()
{
return new iPhone();
}
};
class PersonB_XiaoMi : public Secretary
{
public:
Phone* BuyPhone()
{
return new XiaoMi();
}
};
int main()
{
//秘书叫person1 去买iphone
PersonA_iphone person1 ;
Phone* phone1 = person1.BuyPhone();
phone1->phoneInf();
//秘书叫person2 去买xiaomi
PersonB_XiaoMi person2 ;
Phone* phone2 = person2.BuyPhone();
phone2->phoneInf();
return 0;
}从上可见工厂方法模式组成：
a. 抽象产品。 （这里是phone），java中由一个接口或者抽象类实现。C++中可以由抽象类(含有纯虚函数的类）实现。
b.具体产品。这里指的是各个手机厂商产生的产品，比如iphone,xiaomi等。java中继承或者实现 抽象类和接口，完成实际产品实例的创建。C++中子类实例化对象。
c. 抽象工厂类（这里是秘书），相比于简单工厂模式，增加的，将秘书从实际劳力中解放出来，只负责安排任务，由一个抽象类实现。
d.实际工厂。指的是 实际买手机的人。实际类实例化。
这样将导致，秘书轻松了许多，具体买手机这件事，也比较好做，只要人手够多，一旦要新买个手机，只需要秘书在派个人即可，这样对于秘书而言，依然轻松，可扩展。但是唯一的坏处就是需要花钱雇佣人手，多应于实际代码张就是要多很多实际的类。whatever,事情可以达到要求嘛。
3.抽象工厂模式
第三自然段告诉我们，手机厂商都出系列手机了，前两模式都不适用了，总不可能秘书吩咐A去买iphone1,又叫B去买iphone2吧..当然也可以，但是没必要啊。买iPhone1的肯定可以去买iphone2嘛。所以秘书需要从新规划下任务清单，好重新安排任务了。
//java 抽象工厂模式
//抽象产品类
abstract class phone
{
public abstract void phoneInf();
}
//具体产品
class iphone1 extends phone
{
public void phoneInf()
{
System.out.println("Buy iphone1");
}
}
class iphone1s extends phone
{
public void phoneInf()
{
System.out.println("Buy iphone1s");
}
}
class XiaoMi1 extends phone
{
public void phoneInf()
{
System.out.println("Buy XiaoMi1");
}
}
class XiaoMi1s extends phone
{
public void phoneInf()
{
System.out.println("Buy XiaoMi1s");
}
}
//抽象工厂类
abstract class Secretary
{
public abstract phone BuyPhone_1();//买一代手机
public abstract phone BuyPhone_1s(); //买一代升级版
//public abstract phone BuyPhone_2(); //买二代手机
//继续扩展...
}
//实际工厂类
class PersonA_iphone extends Secretary
{
public phone BuyPhone_1()//买iphone一代手机
{
return new iphone1();
}
public phone BuyPhone_1s()//买iphone1s版
{
return new iphone1s();
}
}
class PersonB_XiaoMi extends Secretary
{
public phone BuyPhone_1()
{
return new XiaoMi1();
}
public phone BuyPhone_1s()
{
return new XiaoMi1s();
}
}
class Main
{
public static void main(String[] args)
{
//秘书分配person1去买iphone1,1s产品
PersonA_iphone person1 = new PersonA_iphone() ;
phone p1 = person1.BuyPhone_1();//personA 买的iphone1
phone p2 = person1.BuyPhone_1s();//personA 买的iphone1s
p1.phoneInf();
p2.phoneInf();
//秘书分配person2去买XiaoMi1,1s产品
PersonB_XiaoMi person2 = new PersonB_XiaoMi();
phone p3 = person2.BuyPhone_1();
p3.phoneInf();
phone p4 = person2.BuyPhone_1s();
p4.phoneInf();
}
}/***********************************************************************
C++实现 抽象工厂模式
*********************************************************************/
#include <iostream>
#include <string>
using namespace std;
//抽象产品类
class Phone
{
public :
virtual void phoneInf() =0; //纯虚函数
};
//实际产品
class iPhone1 : public Phone
{
public:
void phoneInf()
{
cout<<"Buy iPhone1"<<endl;
}
};
class iPhone1s : public Phone
{
public:
void phoneInf()
{
cout<<"Buy iPhone1s"<<endl;
}
};
class XiaoMi1 : public Phone
{
public :
void phoneInf()
{
cout<<"Buy XiaoMi1"<<endl;
}
};
class XiaoMi1s : public Phone
{
public :
void phoneInf()
{
cout<<"Buy XiaoMi1s"<<endl;
}
};
//抽象工厂
class Secretary
{
public:
virtual Phone* BuyPhone1()= 0 ; //买一代手机
virtual Phone* BuyPhone1s()=0; //买1s手机
//...继续扩展
};
//实际工厂
class PersonA_iphone : public Secretary
{
public:
Phone* BuyPhone1()
{
return new iPhone1();
}
Phone* BuyPhone1s()
{
return new iPhone1s();
}
};
class PersonB_XiaoMi : public Secretary
{
public:
Phone* BuyPhone1()
{
return new XiaoMi1();
}
Phone* BuyPhone1s()
{
return new XiaoMi1s();
}
};
int main()
{
//秘书叫person1 去买iphone1,1s
PersonA_iphone person1 ;
Phone* phone1 = person1.BuyPhone1();
Phone* phone2 = person1.BuyPhone1s();
phone1->phoneInf();
phone2->phoneInf();
//秘书叫person2 去买xiaomi1,1s
PersonB_XiaoMi person2 ;
Phone* phone3 = person2.BuyPhone1();
Phone* phone4 = person2.BuyPhone1s();
phone3->phoneInf();
phone4->phoneInf();
return 0;
}分析组成：和工厂方法模式一样：a. 抽象产品。 （这里是phone），java中由一个接口或者抽象类实现。C++中可以由抽象类(含有纯虚函数的类）实现。
b.具体产品。这里指的是各个手机厂商产生的产品，比如iphone1,1s,xiaomi1等。java中继承或者实现 抽象类和接口，完成实际产品实例的创建。C++中子类实例化对象。
c. 抽象工厂类（这里是秘书），相比于简单工厂模式，增加的，将秘书从实际劳力中解放出来，只负责安排任务，由一个抽象类实现。但是对于这样的产品族而言，需要重新设计秘书类了。如本例中。
d.实际工厂。指的是 实际买手机的人。实际类实例化。
设计模式学习(1) --- 3类工厂模式