设计模式1---工厂模式

1.简单工厂模式：

class A ：new A
class B :   new B
自己在你写的业务函数或者创建对象时，不想创建，我只是想拿来用？

class Factory:(建一个工厂类，传入参数，让工厂知道应该创建什么类型的对象)
优点：
1，客户端和具体实现类解耦
2，对于某些对象创建过程比较复杂情况，我们不用考虑这些了
缺点：
1.简单工厂模式，增加新的功能是通过修改源代码实现，不符合开闭原则
2.这个类职责过重，这个类发生问题，会影响很多使用这个工厂的模块

简单工厂模式代码实现：

#include<iostream>
using namespace std;

//抽象水果
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* fruit = factory->CreateFruit("apple");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("banana");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("pear");
	fruit->ShowName();
	delete fruit;
}
int main(void)
{
	test();
	return 0;
}

结果：

我是苹果！
我是香蕉！
我是鸭梨！

2.工厂方法模式=简单工厂模式+开闭原则
具体工厂A 创建： class A
抽象工厂
具体工厂B 创建： class B

                  新增具体工厂C  创建 ： class C

缺点：
类的个数成倍增加，导致越来越多，增加维护成本

优点：
符合开闭原则

工厂方法模式代码：

#include<iostream>
using namespace std;

//抽象水果
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:
	AbstractFruit* CreateFruit()
	{
		return new Apple;
	 }
};

//香蕉工厂
class BananaFactory :public AbstractFruitFactory
{
public:
	AbstractFruit* CreateFruit()
	{
		return new Banana;
	}
};

//鸭梨工厂
class PearFactory :public AbstractFruitFactory
{
public:
	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;
}
int main(void)
{
	test();
	return 0;
}

结果：

我是苹果！

3.抽象工厂模式：抽象工厂针对的产品族（横着的苹果 香蕉 鸭梨），而不是产品等级结构（竖着的所有苹果）若增加一个新的西瓜，不符合开闭原则
苹果 香蕉 鸭梨 法国的
苹果 香蕉 鸭梨 美国的
苹果 香蕉 鸭梨 中国的

中国工厂
creatApple
creatBanana
creatPear

美国工厂
creatApple
creatBanana
creatPear

法国工厂
creatApple
creatBanana
creatPear

代码：

#include<iostream>
using namespace std;

//抽象苹果
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 FrenchApple : 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 FrenchBanana : public AbstractBanana
{
public:
	virtual void ShowName()
	{
		cout << "我是法国香蕉！" << endl;
	}
};

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

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

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

//法国鸭梨
class FrechPear : public AbstractPear
{
public:
	virtual void ShowName()
	{
		cout << "我是法国鸭梨！" << endl;
	}
};

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

//中国工厂
class ChinaFactory :public AbstractFruitFactory
{

public:
	virtual AbstractApple* CreateApple()
	{
		return new ChinaApple;
	}
	virtual AbstractBanana* CreateBanana()
	{
		return new ChinaBanana;
	}
	virtual AbstractPear* CreatePear()
	{
		return new ChinaPear;
	}
};


//美国工厂
class UsaFactory :public AbstractFruitFactory
{

public:
	virtual AbstractApple* CreateApple()
	{
		return new UsaApple;
	}
	virtual AbstractBanana* CreateBanana()
	{
		return new UsaBanana;
	}
	virtual AbstractPear* CreatePear()
	{
		return new UsaPear;
	}
};

//法国工厂
class FrenchFactory :public AbstractFruitFactory
{

public:
	virtual AbstractApple* CreateApple()
	{
		return new FrenchApple;
	}
	virtual AbstractBanana* CreateBanana()
	{
		return new FrenchBanana;
	}
	virtual AbstractPear* CreatePear()
	{
		return new FrechPear;
	}
};

void test()
{
	AbstractFruitFactory* factory = NULL;
	AbstractApple* apple = NULL;
	AbstractBanana* banana = NULL;
	AbstractPear* pear = NULL;

	//中国工厂
	factory = new ChinaFactory;
	apple = factory->CreateApple();
	banana = factory->CreateBanana();
	pear = factory->CreatePear();

	apple->ShowName();
	banana->ShowName();
	pear->ShowName();
}
int main(void)
{
	test();
	return 0;
}

结果：

我是中国苹果！
我是中国香蕉！
我是中国鸭梨！