设计模式(3) 对象创建型模式

01 对象创建型模式概述

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。
通过创建型模式来绕开new，来避免对象创建过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。对象创建是接口抽象之后的第一步工作。

创建型模式分为以下几种：

• 单例（Singleton）模式：保证一个类仅有一个实例，并提供一个访问它的全局结点。
• 简单工厂模式：通过专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。
• 工厂方法（FactoryMethod）模式：定义一个用于创建产品对象的接口，将实际创建工作推迟到子类中。
• 抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品，而无需指定它们具体的类。
• 原型（Prototype）模式：将一个对象作为原型，并且通过拷贝这些原型创建新的对象。
• 建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

02 工厂模式

• 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
• 作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类==就可以完成，这种模式叫“简单工厂模式”。

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

#include<iostream>
#include<string>
using namespace std;
//对象的创建与使用分离
class Fruit
{
public:
	virtual void ShowName()=0;
};

class Apple:public Fruit
{
public:
	virtual void ShowName()
	{
		cout<<"Apple"<<endl;
	}
};

class Orange:public Fruit
{
public:
	virtual void ShowName()
	{
		cout<<"Orange"<<endl;
	}
};

class Lemon:public Fruit
{
public:
	virtual void ShowName()
	{
		cout<<"Lemon"<<endl;
	}
};

//水果工厂
class Factory
{
public:
	//创建对象
	static Fruit* fruit(string whichFruit)
	{
		if(whichFruit=="apple")
		{
			return new Apple;
		}
		else if(whichFruit=="orange")
		{
			return new Orange;
		}
		else if(whichFruit=="lemon")
		{
			return new Lemon;
		}
		else 
			return NULL;
	}
};

void test()
{
	Factory* factory=new Factory;
	Fruit* fruit=factory->fruit("apple");
	fruit->ShowName();
	delete fruit;

	fruit=factory->fruit("lemon");
	fruit->ShowName();
	delete fruit;

	fruit=factory->fruit("orange");
	fruit->ShowName();
	delete fruit;

	delete factory;//释放工厂
}
int main()
{
	test();
	system("pause");
	return 0;
}

工厂方法模式

“工厂方法模式”是对简单工厂模式的进一步抽象化，就是将“产品”也抽象出来，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
简单工厂模式+开闭原则=工厂方法模式
创建过程推迟到子类。

#include<iostream>
#include<string>
using namespace std;

//水果抽象类
class Fruit
{
public:
	virtual void ShowName()=0;
};
//苹果
class Apple:public Fruit
{
public:
	virtual void ShowName()
	{
		cout<<"Apple"<<endl;
	}
};
//橘子
class Orange:public Fruit
{
public:
	virtual void ShowName()
	{
		cout<<"Orange"<<endl;
	}
};
//柠檬
class Lemon:public Fruit
{
public:
	virtual void ShowName()
	{
		cout<<"Lemon"<<endl;
	}
};

//水果工厂
class FruitFactory
{
public:
	virtual Fruit* CreateFruit()=0;
};
//苹果工厂
class Apple:public FruitFactory
{
public:
	virtual void CreateFruit()
	{
		return new Apple;
	}
};
//橘子工厂
class Orange:public FruitFactory
{
public:
	virtual void CreateFruit()
	{
		return new Orange;	
	}
};
//柠檬工厂
class Lemon:public FruitFactory
{
public:
	virtual void CreateFruit()
	{
		return new Lemon;	
	}
};

void test()
{
FruitFactory* factory=NULL;
Fruit* fruit=NULL;

//创建一个苹果工厂
factory=new Apple;
fruit=factory->CreateFruit();
fruit->ShowName();

delete fruit;
delete factory;

//创建一个橘子工厂
factory=new Orange;
fruit=factory->CreateFruit();
fruit->ShowName();

delete fruit;
delete factory;

//创建一个柠檬工厂
factory=new Lemon;
fruit=factory->CreateFruit();
fruit->ShowName();

delete fruit;
delete factory;


}
int main()
{
	test();
	system("pause");
	return 0;
}

抽象工厂模式

抽象工厂模式就是将一些相关的产品组成一个“产品族”，由同一工厂来统一生产。
所以抽象工厂针对的是产品族，而不是产品等级结构。

#include<iostream>
#include<string>
using namespace std;

//苹果
class Apple
{
public:
	virtual void ShowName()=0;
};
//中国苹果
class ChinaApple:public Apple
{
public:
	virtual void ShowName()
	{
		cout<<"ChinaApple"<<endl;
	}
};
//美国苹果
class AmericanApple:public Apple
{
public:
	virtual void ShowName()
	{
		cout<<"AmericanApple"<<endl;
	}
};

//橘子
class Orange
{
public:
	virtual void ShowName()=0;
};
//中国橘子
class ChinaOrange:public Orange
{
public:
	virtual void ShowName()
	{
		cout<<"ChinaOrange"<<endl;
	}
};
//美国橘子
class AmericanOrange:public Orange
{
public:
	virtual void ShowName()
	{
		cout<<"AmerianOrange"<<endl;
	}
};

//柠檬
class Lemon
{
public:
	virtual void ShowName()=0;
};	
//中国柠檬
class ChinaLemon:public Lemon
{
public:
	virtual void ShowName()
	{
		cout<<"ChinaLemon"<<endl;
	}
};
//美国柠檬
class AmericanLemon:public Lemon
{
public:
	virtual void ShowName()
	{
		cout<<"AmericanLemon"<<endl;
	}
};


//抽象工厂 针对产品族
class Factory
{
public:
	virtual Apple* CreateApple()=0;
	virtual Orange* CreateOrange()=0;
	virtual Lemon* CreateLemon()=0;
};

//中国工厂
class ChinaFactory:public Factory
{
public:
	virtual Apple* CreateApple()
	{
	   return new ChinaApple;
	}
	virtual Orange* CreateOrange()
	{
	   return new ChinaOrange;
	}
	virtual Lemon* CreateLemon()
	{
	   return new ChinaLemon;
	}
};
//美国工厂
class AmericanFactory:public Factory
{
public:
	virtual Apple* CreateApple()
	{
	   return new AmericanApple;
	}
	virtual Orange* CreateOrange()
	{
	   return new AmericanOrange;
	}
	virtual Lemon* CreateLemon()
	{
	   return new AmericanLemon;
	}
};

void test()
{
Factory* factory=NULL;
Apple* apple=NULL;
Orange* orange=NULL;
Lemon* lemon=NULL;

//中国工厂的产品族
factory=new ChinaFactory;
apple=factory->CreateApple();
orange=factory->CreateOrange();
lemon=factory->CreateLemon();

apple->ShowName();
orange->ShowName();
lemon->ShoeName();

delete lemon;
delete orange;
delete apple;
delete factory;



//美国工厂的产品族
factory=new AmericanFactory;
apple=factory->CreateApple();
orange=factory->CreateOrange();
lemon=factory->CreateLemon();

apple->ShowName();
orange->ShowName();
lemon->ShoeName();

delete lemon;
delete orange;
delete apple;
delete factory;
}

int main()
{
	test();
	system("pause");
	return 0;
}

可以发现，除了一开始new的地方不一样，其它地方都是一模一样的。