一、虽然简单工厂模式不属于23种设计模式之一，但还是有用武之地。 工厂相当于一个中介，我们只需要往里传入参数。而不需要关心工厂具体怎么创建对象，这就实现客户端和具体实现类的解耦合！比如我们要去商店买果汁，我们不需要知道生产果汁的工厂是怎么把水果榨成汁，只需要知道我们要喝的是苹果汁、雪梨汁还是橙汁。这个过程可以这样描述（为了方便，不考虑is-a和has-a问题，认为果汁就是水果）：
class Fruit {
public:
virtual void type() = 0;//看看需要什么水果？
};
class Apple : public Fruit {
public:
virtual void type() {
cout << "苹果" << endl;
}
};
class Pear : public Fruit {
public:
virtual void type() {
cout << "梨" << endl;
}
};
class Orange : public Fruit {
public:
virtual void type() {
cout << "橙子" << endl;
}
};
//工厂
class Factory {
public:
static Fruit * CreateFruitJuice(string type) {
if (type == "梨汁")
return new Pear;
else if (type == "橙汁")
return new Orange;
else if (type == "苹果汁")
return new Apple;
return NULL;
}
};
void test() {
//创建完工厂后不需要关心具体实现，拿来即用
Factory *factory = new Factory;
Fruit *Juice = factory->CreateFruitJuice("苹果汁");
Juice->type();
delete Juice;
Juice = factory->CreateFruitJuice("橙汁");
Juice->type();
delete Juice;
}这个例子和买股票的例子很相似，这就是简单工厂设计思想。但是简单工厂设计思想存在弊端，如果我们需要增加功能就要修改源代码了（违背开闭原则），而且工厂类一旦出现错误，就会导致使用他的类都发生错误。因此我们提出工厂模式，在简单工厂模式上加上开闭原则。
这样看起来就有保障了，增加了扩展性。而且如果生产橙汁工厂出现问题，只会影响橙汁的好坏，而不会像简单工厂那样导致其他果汁出错了。但是工厂模式还是存在弊端，如果新增加很多果汁，我们就需要写很多个工厂类，维护代码的成本比较高。
class AbstractFruit{
public:
virtual void type() = 0;
};
class Apple : public AbstractFruit{
public:
virtual void type() {
cout << "苹果" << endl;
}
};
class Pear : public AbstractFruit{
public:
virtual void type() {
cout << "梨" << endl;
}
};
class Orange : public AbstractFruit{
public:
virtual void type() {
cout << "橙子" << endl;
}
};
//抽象工厂
class AbstractFruitFactory {
public:
virtual AbstractFruit* CreateFruitJuice() = 0;
};
//生产苹果工厂
class AppleFactory :public AbstractFruitFactory {
public:
virtual AbstractFruit* CreateFruitJuice() {
return new Apple;
}
};
//生产梨汁工厂
class PearFactory :public AbstractFruitFactory {
virtual AbstractFruit* CreateFruitJuice() {
return new Pear;
}
};
//生产橙汁工厂
class OrangeFactory :public AbstractFruitFactory {
virtual AbstractFruit* CreateFruitJuice() {
return new Orange;
}
};
void test()
{
AbstractFruitFactory *factory = new AppleFactory;
AbstractFruit *fruit;
fruit = factory->CreateFruitJuice();
delete fruit;
delete factory;
}
两个工厂使用场景
简单工厂：1、工厂类创建的对象比较少，因此不会使得工厂类中方法的业务逻辑比较复杂。2、只需要知道传入工厂的参数，而不需要知道具体如何创建对象。
工厂模式：1、不知道需要对象的类。2、抽象工厂通过指定子类创建对象
二、抽象工厂
上述的例子我们仅仅做了横向的拓展，接下来我们进行纵向的拓展。横向扩展就是指我们再添加一个种水果，而纵向拓展就是增加一个产地：
因此，可以用抽象工厂来实现：
//苹果的抽象类，提供具体产地的苹果实现
class AbstractApple {
public:
virtual void getName() = 0;
};
//橙子抽象类，提供具体产地橙子实现
class AbstractOrange {
public:
virtual void getName() = 0;
};
class chinaApple :public AbstractApple {
public:
virtual void getName()
{
cout << "中国苹果" << endl;
}
};
class AmericanApple :public AbstractApple {
public:
virtual void getName()
{
cout << "美国苹果" << endl;
}
};
class chinaOrange :public AbstractOrange {
public:
virtual void getName()
{
cout << "中国橙子" << endl;
}
};
class AmericanOrange :public AbstractOrange {
public:
virtual void getName()
{
cout << "美国橙子" << endl;
}
};
//抽象的工厂类，提供具体产品族工厂实现
class ABstratcFactory {
public:
virtual AbstractApple* createApple() = 0;
virtual AbstractOrange* createOrange() = 0;
};
//中国工厂制造中国苹果和橘子
class chinaFactory :public ABstratcFactory {
public:
virtual AbstractApple* createApple() {
return new chinaApple;
}
virtual AbstractOrange* createOrange() {
return new chinaOrange;
}
};
//美国工厂制造美国苹果和橘子
class AmericanFactory :public ABstratcFactory {
public:
virtual AbstractApple* createApple() {
return new AmericanApple;
}
virtual AbstractOrange* createOrange() {
return new AmericanOrange;
}
};
void test() {
ABstratcFactory *factory = new chinaFactory;
AbstractApple *apple = factory->createApple();
AbstractOrange *orange = factory->createOrange();
delete apple;
delete orange;
delete factory;
}