设计模式之工厂模式

简单工厂模式

• 对象不是由用户直接实例，而是交给一个工程类去实例化
• 要增加新的功能需要修改源代码，不符合开闭原则
• 类的职责过重，类发生问题，会影响使用这个类的其他功能

//水果基类
class fruit
{
public:
	virtual void showName()=0;
};
//香蕉类
class banana : public fruit
{
public:
	virtual void showName()
	{	
		cout << "我是香蕉" << endl;
	}
};
//鸭梨类
class Pear :public fruit
{
public:
	virtual void showName()
	{
		cout << "我是鸭梨" << endl;
	}
};
//水果工厂
class fruitFactory
{
public:
	static fruit* CreatFruit(string flag)
	{
		if (flag == "banana") {
			return new banana();
		}
		else if (flag == "Pear") {
			return new Pear();
		}
		else
		{
			return nullptr;
		}
	}
};

void test01()
{
	fruitFactory* factory = new fruitFactory;
	fruit* ban = factory->CreatFruit("banana");
	ban->showName();
	fruit* pear = factory->CreatFruit("Pear");
	pear->showName();
	delete ban;
	delete pear;
	return;
}

工厂方法模式

• 简单工厂模式不符合开闭原则
• 工厂方法模式是把工厂抽象出去，实例化由工厂子类去实现，符合开闭原则
• 类的数量会变多

class fruit
{
public:
	virtual void showName()=0;
};

class apple :public fruit
{
public:
	virtual void showName()
	{
		cout << "我是苹果" << endl;
	}
};

class banana : public fruit
{
public:
	virtual void showName()
	{	
		cout << "我是香蕉" << endl;
	}
};

class Pear :public fruit
{
public:
	virtual void showName()
	{
		cout << "我是鸭梨" << endl;
	}
};

//抽象工厂
class AbstractFactory
{
public:
	virtual fruit* CreatFruit() = 0;
};

//苹果工厂
class appleFactory :public AbstractFactory
{
	virtual fruit* CreatFruit()
	{
		return new apple;
	}
};

//香蕉工厂
class babanaFactory :public AbstractFactory
{
	virtual fruit* CreatFruit()
	{
		return new banana;
	}
};

//鸭梨工厂
class pearFactory :public AbstractFactory
{
	virtual fruit* CreatFruit()
	{
		return new Pear;
	}
};

void test()
{
	AbstractFactory* factory = nullptr;
	fruit* fruitExample = nullptr;

	//创建一个苹果工厂
	factory = new appleFactory();
	fruitExample = factory->CreatFruit();
	fruitExample->showName();
	delete fruitExample;
	delete factory;

	//创建一个香蕉工厂
	factory = new babanaFactory();
	fruitExample = factory->CreatFruit();
	fruitExample->showName();
	delete fruitExample;
	delete factory;

	//创建一个鸭梨工厂
	factory = new pearFactory();
	fruitExample = factory->CreatFruit();
	fruitExample->showName();
	delete fruitExample;
	delete factory;
	return;
}

抽象工厂模式

• 工厂方法模式只能生产同一产品族
• 抽象工厂模式可以生产不同等级结构的产品

//抽象苹果
class AbstractApple
{
public:
	virtual void ShowName() = 0;
};

//中国苹果
class ChinaApple :public AbstractApple
{
public:
	virtual void ShowName()
	{
		cout << "中国苹果" << endl;
	}
};

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

//美国苹果
class AmericanApple :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 JapanBanana :public AbstractBanana
{
public:
	virtual void ShowName()
	{
		cout << "日本香蕉" << endl;
	}
};

//美国香蕉
class AmericanBanana :public AbstractBanana
{
public:
	virtual void ShowName()
	{
		cout << "美国香蕉" << endl;
	}
};

//抽象鸭梨
class AbstractPear
{
public:
	virtual void ShowName() = 0;
};

//中国鸭梨
class ChinaPear :public AbstractPear
{
	virtual void ShowName()
	{
		cout << "中国鸭梨" << endl;
	}
};

//美国鸭梨
class AmericanPear :public AbstractPear
{
	virtual void ShowName()
	{
		cout << "美国鸭梨" << endl;
	}
};

//日本鸭梨
class JapanPear :public AbstractPear
{
	virtual void ShowName()
	{
		cout << "日本鸭梨" << endl;
	}
};

//抽象工厂，针对产品族
class AbstractFactory
{
public:
	virtual AbstractApple* CreateApple() = 0;
	virtual AbstractBanana* CreateBanana() = 0;
	virtual AbstractPear* CreatePear() = 0;
};

//中国工厂
class ChinaFactory :public AbstractFactory
{
public:
	virtual AbstractApple* CreateApple()
	{
		return new ChinaApple;
	}
	virtual AbstractBanana* CreateBanana()
	{
		return new ChinaBanana;
	}
	virtual AbstractPear* CreatePear()
	{
		return new ChinaPear;
	}
};

//美国工厂
class AmericanFactory :public AbstractFactory
{
public:
	virtual AbstractApple* CreateApple()
	{
		return new AmericanApple;
	}
	virtual AbstractBanana* CreateBanana()
	{
		return new AmericanBanana;
	}
	virtual AbstractPear* CreatePear()
	{
		return new AmericanPear;
	}
};

//日本工厂
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 = nullptr;
	AbstractApple* apple = nullptr;
	AbstractBanana* banana = nullptr;
	AbstractPear* pear = nullptr;

	factory = new ChinaFactory();
	apple = factory->CreateApple();
	apple->ShowName();
	banana = factory->CreateBanana();
	pear = factory->CreatePear();
	banana->ShowName();
	pear->ShowName();
	delete factory;
	delete apple;
	delete banana;
	delete pear;

	factory = new JapanFactory();
	apple = factory->CreateApple();
	apple->ShowName();
	banana = factory->CreateBanana();
	pear = factory->CreatePear();
	banana->ShowName();
	pear->ShowName();
	delete factory;
	delete apple;
	delete banana;
	delete pear;

	factory = new AmericanFactory();
	apple = factory->CreateApple();
	apple->ShowName();
	banana = factory->CreateBanana();
	pear = factory->CreatePear();
	banana->ShowName();
	pear->ShowName();
	delete factory;
	delete apple;
	delete banana;
	delete pear;	
	return;
}