设计模式-工厂模式（简单，工厂方法，抽象）

工厂模式

建立对象的类就是一个工厂，被建立的对象就是一个产品，在工厂中加工产品，不用在乎产品如何产生。降低模块耦合。

工厂模式分类

包括 简单工厂模式，工厂方法模式，抽象工厂模式。

1简单工厂模式
由工厂对象决定创建哪一个产品类的实例，这些产品类（继承自父类或接口）。
例如：一个工厂生产A,B两种产品，当客户需要那种产品就告诉工厂。

缺点：当新增加一种产品的时候，就要去修改工厂的类

//实现方法： 定义一个产品接口
class product
{
public:
	virtual void show() = 0;  //接口类
};

class Product_A :public product
{
public:
	void show()
	{
		cout << "A" << endl;
	}
};

class Product_B :public product
{
public:
	void show()
	{
		cout << "B" << endl;
	}
};

class Fact
{
public:
	product* Create(int i)
	{
		switch (i)
		{
		case 1:return new Product_A; break;
		case 2:return new Product_B; break;
		default:break;
		}
	}
};

int main()
{
	Fact* nA = new Fact();
	nA->create(1)->show();
	nA->create(2)->show();

	return 0;
}

工厂方法模式
定义一个用于创建对象的接口，让子类决定实例化哪一个类。

例如：现在有A,B两种产品，那么就要开两个工厂。工厂A负责生产A产品，工厂B负责生产B产品，这个时候客户不需要告诉工厂生产那种产品，只需告诉对应的工厂生产。 若增加产品，则增加一个产品类即可

//实现方法：定义一个产品接口，一个工厂接口
class product
{
public:
	virtual void show() = 0;  //产品接口类
};

class Product_A :public product
{
public:
	void show()
	{
		cout << "A" << endl;
	}
};
class Product_B :public product
{
public:
	void show()
	{
		cout << "B" << endl;
	}
};

class Fact
{
public:
	virtual product* create() = 0;//工厂接口类
};

class Fact_A :public Fact
{
public:
	product* create()
	{
		return new Product_A;
	}
};

class Fact_B :public Fact
{
public:
	product* create()
	{
		return new Product_B;
	}
};

int main()
{
	Fact* nA = new Fact_A();
	nA->create()->show();

	Fact* nB = new Fact_B();
	nB->create()->show();
	return 0;
}

抽象工厂模式
如果A产品有A1和A2两种型号，B产品有B1和B2两种型号，上面两种工厂模式就不能解决。引入抽象工厂模式
例如：开两家工厂，工厂A负责生产A1,A2型号。工厂B负责生产B1,B2型号。

//实现方式：定义一个产品1接口，一个产品2接口，工厂接口，
class product1
{
public:
	virtual void show() = 0;
};

class Product_A1 :public product1
{
public:
	void show()
	{
		cout << "A1" << endl;
	}
};

class Product_B1 :public product1
{
public:
	void show()
	{
		cout << "B1" << endl;
	}
};

class product2
{
public:
	virtual void show() = 0;
};

class Product_A2 :public product2
{
public:
	void show()
	{
		cout << "A2" << endl;
	}
};

class Product_B2 :public product2
{
public:
	void show()
	{
		cout << "B2" << endl;
	}
};

class Fact
{
public:
	virtual product* create1() = 0;
	virtual product* create2() = 0;
};

class Fact_A :public Fact
{
public:
	product* create1()
	{
		return new Product_A1();
	}
	product* create2()
	{
		return new Product_A2();
	}
};

class Fact_B :public Fact
{
public:
	product* create1()
	{
		return new Product_B1;
	}
	product* create2()
	{
		return new Product_B2;
	}
};