设计模式（二）简单工厂模式

一、虽然简单工厂模式不属于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;
}