创建型模式-工厂模式

简单工厂模式

又称静态工厂模式：通过定义一个类，负责创建其他类的实例。被创建的实例通常具有共同的父类。

class Fruit
{
public:
	virtual void getName() = 0;
};
class Apple: public Fruit 
{
public:
	virtual void getName()
	{
		cout<<"apple"<<endl;
	}
};
class Banana: public Fruit
{
public:
	virtual void getName()
	{
		cout<<"banana"<<endl;
	}
};
class Factory
{
public:
	static Fruit* createFruit(string type)
	{
		Fruit* fruit = nullptr;
		if (type == "apple")
			fruit = new Apple();
		if (type == "banana")
			fruit = new Banana();
		return fruit;
	}
	
};


int main(int argc, char *argv[]) {
	Factory* factory = new Factory();
	Fruit* apple = factory -> createFruit("apple");
	Fruit* banana = factory -> createFruit("banana");
	if (apple != nullptr)
		apple -> getName();
	if (banana != nullptr)
		banana -> getName();
}

优点：

• 用户在使用时可以直接根据工厂类去创建所需要的实例，而无需了解这些对象是如何创建及如何组织的，有利于整个软件体系结构的优化。

缺点：

• 不符合开闭原则。当具体产品类不断增多时，会要求工厂类做出响应修改。
• 工厂类中集合了所有实例的创建逻辑，所以“高内聚”做的并不好。

工厂方法模式

又称多态工厂模式：定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。

工厂方法模式VS简单工厂模式

• 结构上不同，工厂方法模式的核心是一个抽象工厂类，简单工厂模式的核心是一个具体工厂类。
• 工厂方法模式之称为多态工厂模式：所有的具体工厂模式都有共同的借口或抽象父类。
• 当添加新产品时，工厂方法模式只需要添加一个具体对象和具体工厂对象，符合开闭原则。

class Fruit
{
public:
	virtual void getName() = 0;
};
class Factory 
{
public:
	virtual Fruit* create() = 0;
};

class Apple: public Fruit
{
public:
	virtual void getName() 
	{
		cout<<"apple"<<endl;
	}
};
class Banana: public Fruit
{
public:
	virtual void getName()
	{
		cout<<"banana"<<endl;
	}
};

class AppleFactory: public Factory
{
public:
	virtual Fruit* create()
	{
		return new Apple();
	}
};
class BananaFactory: public Factory
{
public:
	virtual Fruit* create()
	{
		return new Banana();
	}
};
int main(int argc, char *argv[]) {
	Factory* appleFactory = new AppleFactory();
	Fruit* apple = appleFactory -> create();
	apple -> getName();
	
	Factory* bananaFactory = new BananaFactory();
	Fruit* banana = bananaFactory -> create();
	banana -> getName();
	
	delete apple;
	delete banana;
}

抽象工厂模式

能提供一个借口，在客户端不指定产品的具体类型的情况下，创建多个产品族的产品对象。

抽象工厂模式VS工厂方法模式

• 工厂模式只能生产一个产品
• 抽象工厂模式可以生产一个产品族

class Fruit 
{
public:
	virtual void getName() = 0;
};
class Factory 
{
public:
	virtual Fruit* createApple() = 0;
	virtual Fruit* createBanana() = 0;
};

class SouthApple: public Fruit
{
public:
	virtual void getName() 
	{
		cout<<"south apple"<<endl;
	}
};

class SouthBanana: public Fruit
{
public:
	virtual void getName()
	{
		cout<<"south banana"<<endl;
	}
};
class SouthFactory:public Factory
{
public:
	virtual Fruit* createApple()
	{
		return new SouthApple();
	}
	virtual Fruit* createBanana()
	{
		return new SouthBanana();
	}
};

class NorthApple: public Fruit
{
public:
	virtual void getName() 
	{
		cout<<"north apple"<<endl;
	}
};

class NorthBanana: public Fruit
{
public:
	virtual void getName()
	{
		cout<<"north banana"<<endl;
	}
};
class NorthFactory:public Factory
{
public:
	virtual Fruit* createApple()
	{
		return new NorthApple();
	}
	virtual Fruit* createBanana()
	{
		return new NorthBanana();
	}
};

int main(int argc, char *argv[]) {
	Factory* southFactory = new SouthFactory();
	Fruit* southApple = southFactory -> createApple();
	southApple -> getName();
	Fruit* southBanana = southFactory -> createBanana();
	southBanana -> getName();
	
	Factory* northFactory = new NorthFactory();
	Fruit* northApple = northFactory -> createApple();
	northApple -> getName();
	Fruit* northBanana = northFactory -> createBanana();
	northBanana -> getName();
	
	delete southFactory;
	delete southApple;
	delete southBanana;
	
	delete northFactory;
	delete northApple;
	delete northBanana;
}