工厂模式:分为简单工厂模式、工厂模式、抽象工厂模式三个层次
简单工厂模式,通过一个工厂类实现别的类的创建
缺点:
1、增加新的功能时,需要修改源代码,不符合开闭原则
2、一个工厂类职责过重,类发生问题时,会影响很多实用使用该工厂的模块
//抽象水果
class AbstractFruit{
public:
virtual void Showname() = 0;
};
//两个具体水果
class Apple: public AbstractFruit{
public:
virtual void Showname(){
cout << "我是苹果"<<endl;
}
};
class Banana: public AbstractFruit{
public:
virtual void Showname(){
cout << "我是香蕉"<<endl;
}
};
//水果工厂
class FruitFactory{
public:
static AbstractFruict* CreateFruit(string flag){
if(flag == "apple")
return new Apple;
else if(falg == "banana")
return new Banana;
else
return NULL;
}
};
int main(){
FruitFactor* factory = new FruitFactory;
AbstactFruit* fruit = factory->CreateFruit("apple");
fruit->Showname();
delete fruit;
fruit = factory->CreateFruit("Banana");
fruit->Showname();
delete fruit;
delete factory;
return 0;
}
工厂方法模式:通过抽象工厂指针的多态特性完成不同工厂类函数的调用,不同工厂类完成别的类的创建
好处:符合开闭原则,不需要记住具体类名,可扩展性增强
缺点:类的个数成倍增加(每出现一个新的类,相对应的也会多出一个对应的工厂类),维护成本增加
//抽象水果
class AbstractFruit{
public:
virtual void Showname() = 0;
};
//两个具体水果
class Apple: public AbstractFruit{
public:
virtual void Showname(){
cout << "我是苹果"<<endl;
}
};
class Banana: public AbstractFruit{
public:
virtual void Showname(){
cout << "我是香蕉"<<endl;
}
};
//抽象工厂类
class AbstractFactory{
public:
virtual AbstractFruit* CreateFruit() = 0;
};
//两个具体工厂类:
class AppleFactory: public AbstractFactory{
public:
virtual AbstractFruit* CreateFruit(){
return new Apple;
}
};
class BananaFactory: public AbstractFactory{
public:
virtual AbstractFruit* CreateFruit(){
return new Banana;
}
};
int main(){
AbstractFactory* factory = NULL;
AbstractFruit* fruit = NULL;
factory = new AppleFactory;
fruit = factory->CreateFruit();
fruit->Showname();
delete fruit;
delete factory;
factory = new BananaFactory;
fruit = factory->CreateFruit();
fruit->Showname();
delete fruit;
delete factory;
return 0;
}
抽象工厂模式:针对产品族,不针对产品等级结构
产品族:同一产地或同一厂商,功能不同(如美国产的苹果、香蕉)
产品等级:功能相同,产地或者厂商不同(如美国产的苹果,中国产的苹果)
//抽象苹果
class AbstractApple{
public:
virtual void showname() = 0;
};
//两个具体苹果
class ChinaApple : public AbstractApple{
public:
virtual void showname(){
cout << "中国苹果" <<endl;
}
};
class USAApple : public AbstractApple{
public:
virtual void showname(){
cout << "美国苹果" <<endl;
}
};
//抽象香蕉
class AbstractBanana{
public:
virtual void showname() = 0;
};
//两个具体香蕉
class ChinaBanana : public AbstractBanana{
public:
virtual void showname(){
cout << "中国香蕉" <<endl;
}
};
class USABanana : public AbstractBanana{
public:
virtual void showname(){
cout << "美国香蕉" <<endl;
}
};
//抽象工厂:针对产品族
class AbstractFactory{
public:
virtual AbstractApple* CreateApple() = 0;
virtual AbstractBanana* CreateBanana() = 0;
};
//两个具体工厂
class ChinaFactory: public AbstractFactory{
public:
virtual AbstractApple* CreateApple(){
return new ChinaApple;
}
virtual AbstractBanana* CreateBanana(){
return new ChinaBanana;
}
};
class USAFactory: public AbstractFactory{
public:
virtual AbstractApple* CreateApple(){
return new USAApple;
}
virtual AbstractBanana* CreateBanana(){
return new USABanana;
}
};
int main(){
AbstractFactory* factory = NULL;
AbstractApple* apple = NULL;
AbstractBanana* banana = NULL;
factory = new ChinaFactory;
apple = factory->CreateApple();
banana = factory->CreateBanana();
apple->showname();
banana->showname();
delete apple;
delete banana;
delete factory;
factory = new USAFactory;
apple = factory->CreateApple();
banana = factory->CreateBanana();
apple->showname();
banana->showname();
delete apple;
delete banana;
delete factory;
return 0;
}