设计模式 简单工厂--工厂--抽象工厂

1、简单工厂

 我们假设使用工厂生产苹果，香蕉，梨子，这里我们将苹果，香蕉，梨子都抽象为水果，然后使用一个静态的工厂函数去生产水果，代码很好理解，但不符合开闭原则。比如，当我们又需要生产西瓜的时候，需要修改工厂的源码，增加对if…else…的判断。

#if 1
#include<iostream>
using namespace std;
//简单工厂模式，不符合开闭原则，不算在23种设计模式中
//抽象水果
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 Pear :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是梨子" << endl;
	}
};
//水果工厂
class FruitFactory {
public:
	static AbstractFruit* CreateFruit(string flag) {
		if (flag == "apple") {
			return new Apple;
		}
		else if (flag == "banana") {
			return new Banana;
		}
		else if(flag == "pear") {
			return new Pear;
		}
		else
		return NULL;
	}
};

void test() {
	FruitFactory* factory = new FruitFactory;
	AbstractFruit* fruit1 = factory->CreateFruit("apple");
	fruit1->ShowName();
	AbstractFruit* fruit2 = factory->CreateFruit("banana");
	fruit2->ShowName();
	AbstractFruit* fruit3 = factory->CreateFruit("pear");
	fruit3->ShowName();
	delete fruit1;
	delete fruit2;
	delete fruit3;
	delete factory;
}

int main(void) {
	test();
	return 0;
}

#endif

2、工厂

 工厂模式适合 1、工厂类负责创建的对象比较少，有图创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。2、客户端值知道传入工厂的参数，对于如何创建对象并不关心。
优点：
1、不需要记住具体的类名，甚至具体的参数也不需要记忆
2、实现了对象创建和使用的分离
3、符和开闭原则
缺点：
1、增加系统中类的个数，复杂度增加
2、 增加了系统的抽象性和理解难度

#if 1
#include<iostream>
using namespace std;
//简单工厂模式，不符合开闭原则，不算在23种设计模式中
//抽象水果
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 Pear :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是梨子" << endl;
	}
};

//抽象工厂
class AbstractFruitFactory {
public:
	virtual AbstractFruit* CreateFruit() = 0;
};
//苹果工厂
class AppleFactory :public AbstractFruitFactory {
public:
	virtual  AbstractFruit* CreateFruit() {
		return new Apple;
	}
};

//banana工厂
class BananaFactory :public AbstractFruitFactory {
public:
	virtual  AbstractFruit* CreateFruit() {
		return new Banana;
	}
};
//Pear工厂
class PearFactory :public AbstractFruitFactory {
public:
	virtual  AbstractFruit* CreateFruit() {
		return new Pear;
	}
};


void test() {
	AbstractFruitFactory* factory = NULL;
	AbstractFruit* fruit = NULL;
	//创建苹果工厂
	factory = new AppleFactory();
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	//创建Babana工厂
	factory = new BananaFactory();
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	//创建Pear工厂
	factory = new PearFactory();
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;
}

int main(void) {
	test();
	return 0;
}

#endif

3 抽象工厂

 工厂方法模式通过引入工厂等级结果，解决了简单工厂模式中工厂类职能过重的问题，但由于工厂方法模式中的每个工厂值生产一类产品，可能导致系统存在大量的工厂类，势必增加开销。因此，我们考虑将一些相关的产品组成一个产品族，由同一个工厂来统一生产。
 抽象工厂针对产品族（中国工厂，美国工厂，日本工厂），不针对产品等级结构（苹果，banann,pear）（违背开闭原则）

#if 1
#include<iostream>
using namespace std;
//产品等级
//抽象苹果
class AbstractApple {
public:
	virtual void ShowName() = 0;
};

//中国苹果
class ChineseApple :public AbstractApple {
public:
	virtual void ShowName()
	{
		cout << "中国苹果"<<endl;
	}
};
//美国苹果
class USAApple :public AbstractApple {
public:
	virtual void ShowName()
	{
		cout << "美国苹果" << endl;
	}
};
//日本苹果
class JapanApple :public AbstractApple {
public:
	virtual void ShowName()
	{
		cout << "日本苹果" << endl;
	}
};

//抽象香蕉
class AbstractBanana {
public:
	virtual void ShowName() = 0;
};

//中国香蕉
class ChineseBanana :public AbstractBanana {
public:
	virtual void ShowName()
	{
		cout << "中国香蕉" << endl;
	}
};
//美国香蕉
class USABanana :public AbstractBanana {
public:
	virtual void ShowName()
	{
		cout << "美国香蕉" << endl;
	}
};
//日本香蕉
class JapanBanana :public AbstractBanana {
public:
	virtual void ShowName()
	{
		cout << "日本香蕉" << endl;
	}
};
//抽象鸭梨
class AbstractPear {
public:
	virtual void ShowName() = 0;
};

//中国鸭梨
class ChinesePear :public AbstractPear {
public:
	virtual void ShowName()
	{
		cout << "中国鸭梨" << endl;
	}
};
//美国鸭梨
class USAPear :public AbstractPear {
public:
	virtual void ShowName()
	{
		cout << "美国鸭梨" << endl;
	}
};
//日本鸭梨
class JapanPear :public AbstractPear {
public:
	virtual void ShowName()
	{
		cout << "日本鸭梨" << endl;
	}
};
//抽象工厂 针对产品族
class AbstractFactory {
public:
	virtual AbstractApple* CreateApple() = 0;
	virtual AbstractBanana* CreateBanana() = 0;
	virtual AbstractPear* CreatePear() = 0;
};
//中国工厂
class ChineseFactory: public AbstractFactory {
public:
	virtual AbstractApple* CreateApple() {
		return new ChineseApple;
	}
	virtual AbstractBanana* CreateBanana() {
		return new ChineseBanana;
	}
	virtual AbstractPear* CreatePear() {
		return new ChinesePear;
	}
};
//美国工厂
class USAFactory : public AbstractFactory {
public:
	virtual AbstractApple* CreateApple() {
		return new USAApple;
	}
	virtual AbstractBanana* CreateBanana() {
		return new USABanana;
	}
	virtual AbstractPear* CreatePear() {
		return new USAPear;
	}
};
//日本工厂
class JapanFactory : public AbstractFactory {
public:
	virtual AbstractApple* CreateApple() {
		return new JapanApple;
	}
	virtual AbstractBanana* CreateBanana() {
		return new JapanBanana;
	}
	virtual AbstractPear* CreatePear() {
		return new JapanPear;
	}
};

void test() {
	AbstractFactory* factory = NULL;
	AbstractApple* apple = NULL;
	AbstractBanana* banana = NULL;
	AbstractPear* pear = NULL;
	//中国工厂生产的产品
	factory = new ChineseFactory;
	apple = factory->CreateApple();
	banana = factory->CreateBanana();
	pear = factory->CreatePear();
	apple->ShowName();
	banana->ShowName();
	pear->ShowName();

	delete apple;
	delete banana;
	delete pear;
 	delete factory;
}

int main(void) {
	test();
	return 0;
}

/*
输出：
中国苹果
中国香蕉
中国鸭梨
*/
#endif

4 参考

黑马程序员