0 创建型模式

这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

1 简单工厂模式

简单工厂模式并 不属于 GoF 的 23 种设计模式。

那么为什么要使用工厂模式？示例代码如下：

#include <iostream>

using namespace std;

class Fruit

{

public:

	Fruit(string kind)

	{

		this->kind = kind;

		if (kind == "apple")

		{

			//代表苹果

			//苹果的初始化方式

		}

		else if (kind == "banana")

		{

			//代表香蕉

			//香蕉的初始化方式

		}

	}

	void getName()

	{

		if (this->kind == "apple")

		{

			cout << "我是苹果" << endl;

		}

		else if (this->kind == "banana")

		{

			cout << "我是香蕉" << endl;

		}

	}

private:

	string kind;//代表水果的种类

};

int main(void)

{

	//创建一个苹果

	Fruit *apple = new Fruit("apple");

	apple->getName();

	delete apple;

	//main函数跟Fruit类的构造函数耦合度高， 随着水果种类的增加 构造函数越来越复杂

	return 0;

}

不难看出，Fruit类是一个“巨大的”类，在该类的设计中存在如下几个问题：

1. 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，
   
   代码越长，阅读难度、维护难度和测试难度也越大；而且大量条件语句的存在
   
   还将影响系统的性能，程序在执行过程中需要做大量的条件判断。

2. Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水
   
   果对象的初始化代码和显示代码集中在一个类中实现，违反了“单一职责原
   
   则”，不利于类的重用和维护。

3. 当需要增加新类型的水果时，必须修改Fruit类的源代码，违反了“开
   
   闭原则。

1.1 模式中的角色和职责

工厂（Factory）角色：简单工厂模式的核心，它负责实现创建所有实例

的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

抽象产品（AbstractProduct）角色：简单工厂模式所创建的所有对象的

父类，它负责描述所有实例所共有的公共接口。

具体产品（Concrete Product）角色：简单工厂模式所创建的具体实例

对象

1.2 案例

#include <iostream>

using namespace std;

//抽象的水果类

class Fruit

{

public:

	virtual void getName() = 0;

};

class Apple :public Fruit

{

public:

	virtual void getName()

	{

		cout << "我是苹果" << endl;

	}

 };

class Banana :public Fruit

{

public:

	virtual void getName()

	{

		cout << "我是香蕉" << endl;

	}

};

//添加一个新产品 梨子

class Pear :public Fruit

{

public:

	virtual void getName()

	{

		cout << "我是梨子" << endl;

	}

};

//工厂

class Factory

{

public:

	//水果生产器

	Fruit * createFruit(string kind)

	{

		Fruit *fruit = NULL;

		if (kind == "apple")

		{

			fruit =  new Apple;

		}

		else if(kind == "banana")

		{

			fruit =  new Banana;

		}

		//添加一个梨子   修改了工厂的方法，违背了开闭原则

		else if (kind == "pear")

		{

			fruit = new Pear;

		}

		return fruit;

	}

};

int main(void)

{

	//人们是跟工厂打交道

	Factory *factory = new Factory; //创建一个工厂

	//给我来一个苹果

	Fruit *apple = factory->createFruit("apple");

	apple->getName();

	//香蕉

	Fruit *banana = factory->createFruit("banana");

	banana->getName();

	//梨子

	Fruit *pear = factory->createFruit("pear");

	pear->getName();

	delete apple;

	delete banana;

	delete pear;

	delete factory;

	return 0;

}

1.3 优缺点

优点：

1. 实现了对象创建和使用的分离。

2. 不需要记住具体类名，记住参数即可，减少使用者记忆量。

缺点：

1. 对工厂类职责过重，一旦不能工作，系统受到影响。

2. 增加系统中类的个数，复杂度和理解度增加。

3. 违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。

1.4 适用场景

1. 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂
   
   方法中的业务逻辑太过复杂。

2. 客户端只知道传入工厂类的参数，对于如何创建对象并不关心

2 工厂模式

2.1 模式中的角色和职责

简单工厂模式 + “开闭原则” = 工厂模式

工厂模式比简单工厂模式多一个 抽象工厂角色。

抽象工厂（Abstract Factory）角色：工厂方法模式的核心，任何工厂类

都必须实现这个接口。

工厂（Concrete Factory）角色：具体工厂类是抽象工厂的一个实现，

负责实例化产品对象。

抽象产品（Abstract Product）角色：工厂方法模式所创建的所有对象

的父类，它负责描述所有实例所共有的公共接口。

具体产品（Concrete Product）角色：工厂方法模式所创建的具体实例对象。

2.2 案例

示例代码：

#include <iostream>

using namespace std;

//抽象的水果类

class Fruit

{

public:

	virtual void getName() = 0;

};

class Apple :public Fruit

{

public:

	virtual void getName()

	{

		cout << "我是苹果" << endl;

	}

};

class Banana :public Fruit

{

public:

	virtual void getName()

	{

		cout << "我是香蕉 " << endl;

	}

};

//添加一个梨产品

class Pear : public Fruit

{

public:

	virtual void getName()

	{

		cout << "我是梨子 " << endl;

	}

};

//抽象的工厂类

class AbstractFactory

{

public:

	virtual Fruit * createFruit() = 0;//抽象的水果生产器

};

//苹果的工厂

class AppleFactory :public AbstractFactory

{

public:

	virtual Fruit * createFruit()

	{

		return new Apple;

	}

};

//香蕉工厂

class BananaFactory : public AbstractFactory

{

public:

	virtual Fruit *createFruit()

	{

		return new Banana;

	}

};

//梨的工厂

class PearFactory :public AbstractFactory

{

public:

	virtual Fruit *createFruit()

	{

		return  new Pear;

	}

};

int main(void)

{

	/*

		根据依赖倒转原则针对接口编程，

		怎么针对接口编程？

		就是 只需要使用抽象工厂类的指针，和抽象水果类的指针，

		通过多态的特性，就可以搞定完成具体类的业务。

	*/

	AbstractFactory *abFactory = NULL;

	Fruit *fruit = NULL;

	// 抽象水果类指针，完成 Apple 业务

	abFactory = new AppleFactory;

	fruit = abFactory->createFruit();

	fruit->getName();

	delete abFactory;

	delete fruit;

	// 抽象水果类指针，完成 Banana 业务

	abFactory = new BananaFactory;

	fruit = abFactory->createFruit();

	fruit->getName();

	delete abFactory;

	delete fruit;

	// 抽象水果类指针，完成 Pear 业务

	abFactory = new PearFactory;

	fruit = abFactory->createFruit();

	fruit->getName();

	delete abFactory;

	delete fruit;

	return 0;

}

运行结果：

2.3 优缺点

优点：

1. 不需要记住具体类名，甚至连具体参数都不用记忆。

2. 实现了对象创建和使用的分离。

3. 系统的可扩展性也就变得非常好，无需修改接口和原类。

缺点：

1. 增加系统中类的个数，复杂度和理解度增加。

2. 增加了系统的抽象性和理解难度。

2.4 适用场景

1. 客户端不知道它所需要的对象的类。

2. 抽象工厂类通过其子类来指定创建哪个对象。

3 抽象工厂模式

由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑 将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是抽象工厂模式的基本思想。

工厂方法模式+ “产品族” = 抽象工厂方法模式

3.1 产品族与产品等级结构

3.2 模式中的角色和职责

抽象工厂（Abstract Factory）角色：它声明了一组用于创建 一族产品 的方法，每一个方法对应一种产品。

具体工厂（Concrete Factory）角色：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。

抽象产品（Abstract Product）角色：它为 每种产品 声明接口，在抽象产品中声明了产品所具有的业务方法。

具体产品（Concrete Product）角色：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

3.3 案例

示例代码：

#include <iostream>

using namespace std;

// 苹果抽象类，供具体产地苹果实现

class AbstractApple

{

public:

	virtual void getName() = 0;

};

// 香蕉抽象类，供具体产地香蕉实现

class AbstractBanana

{

public:

	virtual void getName() = 0;

};

// 苹果产品族

class ChinaApple : public AbstractApple

{

public:

	virtual void getName()

	{

		cout << "中国苹果" << endl;

	}

};

class USAApple : public AbstractApple

{

public:

	virtual void getName()

	{

		cout << "美国苹果" << endl;

	}

};

class JapanApple : public AbstractApple

{

public:

	virtual void getName()

	{

		cout << "日本苹果" << endl;

	}

};

// 香蕉产品族

class ChinaBanana : public AbstractBanana

{

public:

	virtual void getName()

	{

		cout << "中国香蕉" << endl;

	}

};

class USABanana : public AbstractBanana

{

public:

	virtual void getName()

	{

		cout << "美国香蕉" << endl;

	}

};

class JapanBanana : public AbstractBanana

{

public:

	virtual void getName()

	{

		cout << "日本香蕉" << endl;

	}

};

// 抽象的工厂类，供具体产品族的工厂实现

class AbstractFactory

{

public:

	virtual AbstractApple *createApple() = 0;

	virtual AbstractBanana *createBanana() = 0;

};

// 中国工厂

class ChinaFactory : public AbstractFactory

{

	virtual AbstractApple *createApple()

	{

		return new ChinaApple;

	}

	virtual AbstractBanana *createBanana()

	{

		return new ChinaBanana;

	}

};

// 美国工厂

class USAFactory : public AbstractFactory

{

	virtual AbstractApple *createApple()

	{

		return new USAApple;

	}

	virtual AbstractBanana *createBanana()

	{

		return new USABanana;

	}

};

// 日本工厂

class JapanFactory : public AbstractFactory

{

	virtual AbstractApple *createApple()

	{

		return new JapanApple;

	}

	virtual AbstractBanana *createBanana()

	{

		return new JapanBanana;

	}

};

int main(void)

{

	// 要一个中国的苹果，美国的苹果，日本的香蕉

	AbstractApple *apple = NULL;

	AbstractBanana *banana = NULL;

	AbstractFactory *factory = NULL;

	factory = new ChinaFactory;

	// 中国的苹果

	apple = factory->createApple();

	apple->getName();

	delete apple;

	delete factory;

	factory = new USAFactory;

	// 美国的苹果

	apple = factory->createApple();

	apple->getName();

	delete apple;

	delete factory;

	factory = new JapanFactory;

	// 日本的香蕉

	banana = factory->createBanana();

	banana->getName();

	delete banana;

	delete factory;

	return 0;

}

运行结果：

3.4 优缺点

优点：

1. 拥有工厂方法模式的优点

2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端
   
   始终只使用同一个产品族中的对象。

3. 增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点：

1. 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需
   
   要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

3.5 适用场景

(1) 系统中有多于一个的产品族。而每次只使用其中某一产品族。可以通过

配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产

品族。

(2) 产品等级结构稳定。设计完成之后，不会向系统中增加新的产品等级结

构或者删除已有的产品等级结构。

4 单例模式

定义：保证 一个类只有一个实例存在，同时 提供能对该实例加以访问的全局

访问方法。

要点：

1. 某个类只能有一个实例

2. 它必须自行创建这个实例

3. 它必须自行向整个系统提供这个实例

4.1 模式中的角色和职责

Singleton（单例）：在单例类的内部实现 只生成一个实例，同时它提供一个 静态的 getInstance() 工厂方法，让客户可以访问它的唯一实例；为了防止在外部对其实例化，将其 构造函数设计为私有；在 单例类内部定义了一个 Singleton 类型的静态对象，作为外部共享的唯一实例。

单例模式的使用步骤：

1. 构造函数私有化。

2. 提供一个全局的静态方法（全局访问点）来获取单例对象。

3. 在类中定义一个静态指针，指向本类的变量的静态变量指针 。

4.2 案例

单例模式的 两种实现方式：

1. 懒汉式：在调用全局静态方法，获取单例的时候再进行创建。懒汉式的单例创建在程序的执行中进行。

2. 饿汉式：在声明的时候就创建出来单例。饿汉式的单例是在编译的时候就已经创建好了。

示例代码如下：

#include <iostream>

using namespace std;

// 懒汉模式

class Singelton_lazy

{

public:

	// 对外提供一个全局的静态方法

	static Singelton_lazy* getInstance()

	{

		// 懒汉式：在调用全局静态方法获取单例的时候，再进行创建。

		if(instance == NULL)

		{

			instance = new Singelton_lazy;

		}

		m_count++;

		return instance;

	}

	int getCount()

	{

		return m_count;

	}

private:

	// 构造函数私有化

	Singelton_lazy()

	{

		instance = NULL;

		m_count = 0;

		cout<< "构造函数 Singelton_lazy() 执行" << endl;

	}

	// 在类中定义一个静态指针，指向本类的变量的静态变量指针

	static Singelton_lazy* instance;

	static int m_count;

};

// 对静态变量的初始化要放在全局位置上

Singelton_lazy* Singelton_lazy::instance = NULL;

int Singelton_lazy::m_count = 0;

// 饿汉模式

class Singelton_hungry

{

public:

	static Singelton_hungry* getInstance()

	{

		m_count++;

		return instance;

	}

	int getCount()

	{

		return m_count;

	}

private:

	Singelton_hungry()

	{

		instance = NULL;

		m_count = 0;

		cout<< "构造函数 Singelton_hungry() 执行" << endl;

	}

	static Singelton_hungry* instance;

	static int m_count;

};

// 饿汉式的单例是在声明的时候就创建出来，所以在编译的时候就已经创建好了。

Singelton_hungry* Singelton_hungry::instance = new Singelton_hungry;

int Singelton_hungry::m_count = 0;

int main(void)

{

	cout << "--- 以下是懒汉式 ---" << endl;

	Singelton_lazy* singelton_lazy1 = Singelton_lazy::getInstance();

	cout << singelton_lazy1->getCount() << endl;

	Singelton_lazy* singelton_lazy2 = Singelton_lazy::getInstance();

	cout << singelton_lazy2->getCount() << endl;

	if(singelton_lazy1 == singelton_lazy2)

	{

		cout << "二者是同一个实例" << endl;

	}

	else

	{

		cout << "二者不是同一个实例" << endl;

	}

	cout << "--- 以下是饿汉式 ---" << endl;

	Singelton_hungry* singelton_hungry1 = Singelton_hungry::getInstance();

	cout << singelton_hungry1->getCount() << endl;

	Singelton_hungry* singelton_hungry2 = Singelton_hungry::getInstance();

	cout << singelton_hungry2->getCount() << endl;

	if(singelton_hungry1 == singelton_hungry2)

	{

		cout << "二者是同一个实例" << endl;

	}

	else

	{

		cout << "二者不是同一个实例" << endl;

	}

}

运行结果：

4.3 优缺点

优点：

(1) 单例模式提供了对唯一实例的受控访问。

(2) 节约系统资源。由于在系统内存中只存在一个对象。

缺点：

(1) 扩展略难。单例模式中没有抽象层。

(2) 单例类的职责过重

4.4 适用场景

(1) 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器

或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问

点，不能通过其他途径访问该实例。

最新文章

1. opencart邮件模板
2. Spring MVC中Session的正确用法<转>
3. c#语言-高阶函数
4. CSS魔法堂：小结一下Box Model与Positioning Scheme
5. SqlCommandBuilder实现大数据更新
6. Oracle数据库建表+添加数据练习
7. go again
8. GridView九宫格菜单实现方式
9. MVC5+EF6+BootStrap3.3.5 博客系统之项目搭建（一）
10. Java jdbc数据库连接池总结!(转)
11. ARCGIS获取图层下的要素信息及要素类转换为要素
12. HIVE：用外连接替代子查询
13. CodeKata
14. Nginx学习之三-ngx_http_request_t结构体
15. squid和varnish的小结
16. github上一些觉得对自己工作有用的项目收集
17. asp.net -mvc框架复习（5）-ASP.NET MVC中的视图简单使用
18. [转]maven打包报错：Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.5:test
19. JS中ptototype和__proto__的关系
20. Android编译安装失败解决办法

热门文章

1. 网站搭建-云服务器ECS-镜像管理
2. 6.Android-五大布局
3. day42 Pyhton 并发编程05
4. rabbitmq 延时队列 插件方式实现 每条消息都延时自己时间
5. requests-html添加header
6. maven项目导入eclipse报错
7. BlockCanary界面卡顿检测
8. js 值类型与引用类型
9. ES2020链判断运算符?.和Null判断运算符??
10. zookeeper Cli的常用命令