设计模式之创建型模式（简单工厂模式、工厂模式、抽象工厂模式、建造者模式、单例模式）

最新推荐文章于 2026-05-21 14:00:43 发布
原创 最新推荐文章于 2026-05-21 14:00:43 发布 · 571 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#设计模式
本文详细介绍了创建型设计模式，包括简单工厂模式、工厂模式、抽象工厂模式、建造者模式和单例模式。这些模式分别适用于不同的场景，如简单工厂模式适合创建对象较少且类型固定的系统，工厂模式通过工厂子类实现对象创建的多态性，抽象工厂模式则处理多个产品族的创建。建造者模式用于构建复杂对象，而单例模式确保一个类只有一个实例。每种模式都有其优缺点，需要根据实际需求选择合适的模式。

1、创建型模式

主要关注点是：“怎样创建对象？”

主要特点是：“将对象的创建与使用分离”

这样使用者不需要关注对象的创建细节，对象的创建由相应的工厂实现。
（隐藏了对象如何被创建和组合在一起）

包括五种：
简单工厂模式（Simple Factory）
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）
建造者模式（Builder）
单例模式（Singleton）

2、简单工厂模式

2.1 定义

简单工厂模式(Simple Factory Pattern)因为内部使用静态方法根据不同参数构造不同产品对象实例，也称静态工厂方法模式。

在简单工厂模式中，可以根据参数的不同返回不同实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

2.2 模式结构
  • 工厂角色：工厂角色负责实现创建所有实例的内部逻辑。工厂类内部提供静工厂方法，用于创建所需产品对象，可被外界直接调用。
  • 抽象产品角色：抽象产品角色是所创建的所有对象的父类，负责描述所有的实例所共有的公共接口。抽象产品是工厂类创建创建的所有对象的父类或共有的接口，封装各种产品对象的公有方法。
  • 具体产品角色：具体产品角色是创建目标，所有的创建的对象都充当这个角色的某个具体类的实例。每个具体产品都继承了抽象产品角色，实现抽象产品角色中的抽象方法。

在这里插入图片描述

2.3 C++代码

简单工厂模式的核心是，对于一个父类的多个继承子类，工厂对象的工厂函数根据用户输入，自动new出一个子类对象并返回其父类的指针，这样利用父类的指针执行父类的虚函数，就可以动态绑定子类的重写函数，从而实现多态。

在这里插入图片描述

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>


using namespace std;

//抽象产品类-操作
class Operation
{
private:
	double A, B;
public:
	Operation() :A(0), B(0) {}
	double GetA() const { return A; }
	double GetB() const { return B; }
	void SetA(double x) { A = x; }
	void SetB(double y) { B = y; }
	virtual double GetResult() = 0;
	/*
	double GetA() const{return A;}中的const：
	只有函数是一个类的非静态成员函数才可以。
	类的非静态成员函数不管有几个参数，都会隐形的传入一个参数this
	this是指向该类的指针，加了const以后，表示不可以更改这个对象的成员变量。
	如return A++; 编译的时候就会报错。其实是A是this->A
	*/
};

//具体产品类-加法
class Add :public Operation
{
public:
	double GetResult() { return GetA() + GetB(); }
};

//具体产品类-减法
class Sub :public Operation
{
public:
	double GetResult() { return GetA() - GetB(); }
};

//具体产品类-乘法
class Mul :public Operation
{
public:
	double GetResult() { return GetA()*GetB(); }
};

//具体产品类-除法
class Div :public Operation
{
public:
	double GetResult() { return GetA() / GetB(); }
};

//工厂类
class SimpleFactory
{
public:
	static Operation* CreateOperator(char ch)
	{
		Operation* p=NULL;
		switch (ch)
		{
		case '+':
			p = new Add();
			break;
		case '-':
			p = new Sub();
			break;
		case '*':
			p = new Mul();
			break;
		case '/':
			p = new Div();
			break;
		}
		return p;
	}
};

int main()
{
	double A = 0;
	double B = 0;
	char ch= '\0';
	cin >> A >> ch >> B;

	Operation* op=SimpleFactory::CreateOperator(ch);
	op->SetA(A);
	op->SetB(B);
	cout << op->GetResult() << endl;

	delete op;
	return 0;
}
2.4 模式分析
  • 调用工厂类的工厂方法时，由于工厂方法时静态方法，可以通过类名直接调用，而且只需要传入一个简单的参数即可。
  • 但是它破坏了开闭原则（即只添加不修改）。当想要添加对象类型，例如想添加“^”的运算，则需要添加一个乘方类并且需要修改简单工厂类。
  • 将对象的创建和对象业务处理分离可以降低系统的耦合度，使得二者修改起来都相对容易。
  • 要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无需知道其创建细节。
2.5 优点
  • 客户端不需要创建产品对象，仅仅消费对象即可；简单工厂模式通过这种做法实现了对责任的分割。
  • 无需知道具体产品类的类名，只需要知道对应的参数即可。
  • 通过引入配置文件，可以在不需要修改任何客户端代码的情况下更新和增加具体的产品类，提高了系统的灵活性
2.6 缺点
  • 工厂类集中所有产品的创建逻辑，一旦不能正常工作，整个系统都要受到影响。
  • 使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。
  • 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。
  • 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。
2.7 适用环境
  • 工厂类负责创建的对象比较少：由于创建的对象比较少，不会造成工厂方法中的业务逻辑太过复杂。
  • 客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不关心创建细节，甚至连类名都不需要记住，只需要记住类型所对应的参数。

3、工厂模式

3.1 定义

现在对系统进行修改，不再设计一个按钮工厂类来统一负责所有产品的创建，而是将具体按钮的创建过程交给专门的工厂子类去完成。

在工厂方法模式中，工厂父类定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象。

这样子做的目的时将产品类的实例操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

3.2 模式结构
  • 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
  • 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
  • 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
    在这里插入图片描述
3.3 C++代码

#include <iostream>

using namespace std;

//抽象产品
class Product
{
public:
		virtual void show() = 0;
};

//具体产品1
class ConcreteProduct1 :public Product
{
public:
		void show()
		{
			cout << "具体产品1" << endl;
		}
};

//具体产品2
class ConcreteProduct2 :public Product
{
public:
		void show()
		{
			cout << "具体产品2" << endl;
		}
};

//抽象工厂
class AbstractFactory
{
public:
	virtual Product* newProduct() = 0;
};

//具体工厂1
class ConcreteFactory1 :public AbstractFactory
{
public:
	Product* newProduct()
	{
		return new ConcreteProduct1();
	}
};

//具体工厂2
class ConcreteFactory2 :public AbstractFactory
{
public:
	Product* newProduct()
	{
		return new ConcreteProduct2();
	}
};

int main()
{
	ConcreteFactory1 cf_1;
	Product *pd_1 = cf_1.newProduct();
	pd_1->show();

	ConcreteFactory2 cf_2;
	Product *pd_2 = cf_2.newProduct();
	pd_2->show();

	delete pd_1,pd_2;
	return 0;
}

在这里插入图片描述

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

//抽象产品
class Log
{
private :
	string name;
public:
	string getName() { return name; }
	void setName(string name) { this->name = name; }
	virtual void writeLog() = 0;
};

//具体产品
class FileLog :public Log
{
public:
	void writeLog()
	{
		cout << this->getName() << endl;
	}
};

class DatabaseLog :public Log
{
public:
	void writeLog()
	{
		cout << this->getName() << endl;
	}
};

//抽象工厂
class LogFactory
{
public:
	virtual Log* createLog(string log)throw(int, string);
};

//具体工厂
class FileLogFactory :public LogFactory
{
public:
	Log* createLog(string log)throw(int) {
		return new FileLog();
	}
};

//具体工厂
class DatabaseFactory :public LogFactory
{
public:
	Log* createLog(string log)throw(string)
	{
		return new DatabaseLog();
	}
};

Log * LogFactory::createLog(string log) throw(int, string)
{
	return nullptr;
}
class Client
{
public:
	
	static void main()throw (int, string) {
		LogFactory* a = new FileLogFactory();
		Log* b = a->createLog("filelog");
		b->setName("filelog");
		b->writeLog();
		delete a, b;
	}  
};

int main(){
	Client c;
	c.main();
	return 0;
}
3.4 模式分析

使用面向对象的多态性

这个核心的工厂类不再负责所有产品的创建，而是将具体的创建工作去做。这个核心类只负责给出具体工厂必须实现的接口。

这是得工作方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

3.5 优点
  • 用户只需要关心所需要的产品对应的工厂，无须关心创建细节。
  • 基于工厂角色和产品角色的多态性设计是工厂模式的关键。
  • 向系统添加新产品时，无须修改抽象工厂和抽象产品提供的接口，无需修改客户端，也无需修改其他的具体工厂和具体产品，而只需要添加一个具体工厂和具体产品就可以了。完全符合“开闭原则”。
3.6 缺点
  • 系统类的个数将成对增加，在一定程度上增加系统的复杂度。有更多的类需要编译和运行，会给系统带来一些额外的开销。
  • 引入抽象层，增加系统的抽象性和理解难度。
3.7 适用环境
  • 一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；
  • 一个类通过其子类来指定创建哪些对象：利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将会覆盖父类对象，从而使得系统更容易扩展。
  • 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

4、抽象工厂模式

4.1 定义

在工厂模式中具体工厂负责生产具体的产品，每一个具体工厂对应一个具体产品，一个具体工厂只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂提供多个产品对象，而不是单一的产品对象。

  • 产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机构成一个产品等级结构。抽象电视机是父类，而具体品牌电视机是其子类。
  • 产品族：在抽象工厂模式中，产品族是同一个工厂生产的，位于不同产品等级中的一组产品，如海尔电气工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。

当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。

工厂模式针对是一个产品等级结构，抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。

抽象工厂模式：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式又称为Kit模式。

在这里插入图片描述需要满足的条件：

  • 系统中有对各产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
  • 系统一次只可能消费某一族产品，即同族产品一起使用。
4.2 模式结构
  • 抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
  • 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
  • 抽象工厂：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
  • 具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
    在这里插入图片描述
4.3 C++代码
#include <iostream>
#include <string>
using namespace std;

//抽象产品-产品等级A
class  AbstractProductA {
public:
	virtual void use() = 0;
};

//具体产品-产品等级A-产品族1
class ProductA1:public AbstractProductA 
{
public:
	void use() {
		cout << "use Product A1"<<endl;
	}
};

//具体产品-产品等级A-产品族2
class ProductA2:public AbstractProductA
{
public:
	void use() {
		cout << "use Product A2" << endl;
	}
};

//抽象产品-产品等级B
class  AbstractProductB {
public:
	virtual void eat() = 0;
};

//具体产品-产品等级B-产品族1
class ProductB1 :public AbstractProductB
{
public:
	void eat() {
		cout << "eat Product B1" << endl;
	}
};

//具体产品-产品等级B-产品族2
class ProductB2 :public AbstractProductB
{
public:
	void eat() {
		cout << "eat Product B2" << endl;
	}
};

//抽象工厂
class AbstractFactory 
{
public:
	virtual AbstractProductA* createProductA() = 0;
	virtual AbstractProductB* createProductB() = 0;
};

//具体工厂
class ConcreteFactory1:public AbstractFactory 
{
public:
	AbstractProductA* createProductA()
	{
		return new ProductA1();
	}

	AbstractProductB* createProductB()
	{
		return new ProductB1();
	}
};

//具体工厂
class ConcreteFactory2 :public AbstractFactory
{
public:
	AbstractProductA* createProductA()
	{
		return new ProductA2();
	}

	AbstractProductB* createProductB()
	{
		return new ProductB2();
	}
};


int main() 
{
	AbstractFactory *cf1=new ConcreteFactory1();
	AbstractProductA *pa1 = cf1->createProductA();
	AbstractProductB *pb1 = cf1->createProductB();
	pa1->use();
	pb1->eat();

	AbstractFactory *cf2 = new ConcreteFactory2();
	AbstractProductA *pa2 = cf2->createProductA();
	AbstractProductB *pb2 = cf2->createProductB();
	pa2->use();
	pb2->eat();

	delete cf1, cf2;
	delete pa1, pb1, pa2, pb2;
	return 0;
}
4.4 优点
  • 抽象工厂模式隔离了具体类的生成，使得客户并不需要直到什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂实现了抽象中定义的那些接口，因此只需要改变具体工厂的实例，就可以在某种程序上改变整个软件系统的行为。实现了高内聚低耦合的设计目的。
  • 能保证客户端始终只使用同一个产品族的对象。
  • 增加新的具体工厂和产品族很方便，无需修改已有的系统，符合“开闭原则”。
4.5 缺点
  • 添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，带来极大的不便
  • 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）：
    （1）增加产品族：对于增加新的产品族，工厂方法模式很好的支持了“开闭原则”，对于新增加的产品族，只需要对应增加一个新的具体工厂即可，对已有代码无须做任何修改。
    （2）增加产品等级结构：对于增加新的产品等级结构，需要修改所有的工厂角色，包括抽象工厂类，在所有的工厂类中都需要增加生产新产品的方法，不能很好地支持“开闭原则”。
4.6 适用环境
  • 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
  • 系统中有多于一个的产品族，而每次只使用某一产品族。
  • 属于某一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
  • 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

5、建造者模式

5.1 定义

无论是在现实世界还是软件系统，都存在一些复杂的对象，它们拥有多个足证部分，如汽车，它包括车轮、方向盘、发动机等各种部件。而对于大度哦书用户而言，无需知道这些部件的装配细节，也几乎不会使用单独某个部件，而是使用一辆完成的汽车。

建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

在软件开发中，也存在大量类似汽车一样的复杂对象，他们拥有一系列成员属性，这些成员属性中有些是引用类型的成员对象。而且这些复杂对象中，还可能存在一些限制条件，如某些属性没有赋值则复杂对象不能作为一个完整的产品使用；有些属性的赋值必须按照某个顺序，一些属性没有赋值之前另外一个属性可能无法复赋值等。

建造者模式：指将一个复杂对象的构造和它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式称为建造者模式。它是将一个复杂对象分解为多个简单的对象，然偶一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

5.2 模式结构
  • 抽象建造者：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的复杂方法 getResult()。
  • 具体建造者：实现抽象建造者的接口，完成复杂产品的各个部件的具体创建方法。
  • 指挥者：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。
  • 产品角色：它是包含多个组成部件的复杂对象，由具体建造则来创建其各个部件。
  • 在这里插入图片描述
5.3 C++代码
#include <iostream>
#include <string>
using namespace std;

//产品角色：包含多个组成部件的复杂对象
class Product
{
private:
	string partA;
	string partB;
	string partC;
public:
	void setPartA(string partA) 
	{
		this->partA = partA;
	}
	void setPartB(string partB)
	{
		this->partB = partB;
	}
	void setPartC(string partC)
	{
		this->partC = partC;
	}
	void show() {
		//显示产品特性
		cout << partA << endl << partB <<endl<< partC << endl;
	}
};

//抽象建造者：包含创建产品各个子部件的抽象方法
class AbstractBuilder 
{
protected:
	Product *product;
public:
	virtual void buildPartA() = 0;
	virtual void buildPartB() = 0;
	virtual void buildPartC() = 0;
	AbstractBuilder() { product = new Product(); }
	~AbstractBuilder() { delete product; }
	Product*  getResult()
	{
		return product;
	}
};

//具体建造者：实现了抽象建造者的接口
class ConcreteBuilder:public AbstractBuilder
{
public:
	void buildPartA() 
	{
		product->setPartA("建造 PartA");
	}
	void buildPartB()
	{
		product->setPartB("建造 PartB");
	}
	void buildPartC()
	{
		product->setPartC("建造 PartC");
	}
};

//指挥者：调用建造者中的方法完成对复杂对象的创建
class Director
{  
private:
	AbstractBuilder *builder;
public:
	Director(AbstractBuilder *builder)
	{
		this->builder = builder;
	}
	Product* construct() 
	{
		builder->buildPartA();
		builder->buildPartB();
		builder->buildPartC();
		return builder->getResult();
	}
};

class Client
{
public:
	static void main() 
	{
		AbstractBuilder *builder = new ConcreteBuilder();
		Director * director = new Director(builder);
		Product *product = director->construct();
		product->show();

		delete builder, director;
	}
};

int main()
{
	Client::main();
	return 0;
}
5.4 优点
  • 客户端不必知道产品内部组成细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
  • 每一个具体建造者都相对独立，因此可以很方便的替换具体建造者或者增加新的具体建造者。用户使用不同的具体建造者即可得到不同的产品对象。
  • 可以更加精细的控制产品的创建过程。
  • 增加新的具体建造者无需修改原有的类库代码。符合“开闭原则”。
5.5 缺点
  • 建造者模式所创建的产品一般具有较多的共同点，组成部分相似，如果产品差异性很大，则不适合使用。
  • 如果产品内部变化复杂，可能回导致需要定义很多具体建造者来实现这种变化，导致系统变的很庞大。
5.6 适用环境
  • 需要需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
  • 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
  • 对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中。
  • 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
5.7 简化
  • 省略抽象建造者角色：如果系统中只需要一个具体建造者的话，可以省略掉抽象建造者。
  • 省略指挥者角色：在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略指挥者角色，让Builder角色扮演指挥者与建造者双重角色。

6、单例模式

6.1 定义

对于系统中的某些类来说，只有一个实例很重要，例如，译者系统中可以存在多个打印任务，但是又能有一个正在工作的任务。

让类自身保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。

**单例模式：**确保某一个类只有一个实例，而且自行实例化想整个系统提供这个实例，这个类成为单例类，它提供全局访问的方法。

单例模式的要点有三个：

  1. 某个类只能有一个实例
  2. 它必须自行创建这个实例
  3. 它必须自行向整个系统提供这个实例
6.2 模式结构
  • 单例类：包含一个实例且能自行创建这个实例的类
  • 访问类：使用单例的类

在这里插入图片描述

6.3 C++代码
#include <iostream>
#include <string>
using namespace std;

//懒汉式单例
/*
	该模式的特点是类加载的时候没有生成单例，只有当第一次调用getInstance
	方法时采取创建这个单例
*/
class LazySingleton 
{
private:
	static  LazySingleton* instance;
	LazySingleton() {}//private避免类在外部被实例化

public:
	static LazySingleton* getInstance()
	{
		if (instance == NULL)
		{
			instance = new LazySingleton();
		}
		return instance;
	}
};

//饿汉式单例
/*
	该模式的特点是类一旦加载就创建一个单例，
	保证在调用getInstance方法之前单例就已经存在了
*/

class HungrySingleton 
{
private:
	static HungrySingleton *instance;
	HungrySingleton() {}
public:
	static HungrySingleton* getInstance() 
	{
		return instance;
	}
};

HungrySingleton *HungrySingleton ::instance= new HungrySingleton();

class Client
{
protected:
	static LazySingleton* ls;
	static HungrySingleton* hs;
public:
	static void main()
	{
		ls=LazySingleton::getInstance();
		hs=HungrySingleton::getInstance();
	}
};
6.4 优点
  • 提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它，并为设计及开发团队提供了共享的概念。
  • 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
  • 允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。
6.5 缺点
  • 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
  • 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
  • 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致对象状态的丢失。
6.6 适用环境
  • 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器，或者需要考虑资源消耗太大而只允许创建一个对象。
  • 当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
  • 当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
5.6 扩展为多例模式

在这里插入图片描述

JavaScript设计模式（二）：创建型设计模式-简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式
You瞧谁不起 - 道不尽世间的沧桑，诉不完人生的悲凉
10-17 562
通过对类的工厂抽象使其业务用于对产品类簇的创建，而不负责创建某一类产品的实例。抽象方法只负责告诉开发者要实现什么方法，并不负责真正的逻辑处理，可以理解为子类要实现所定义功能的模板// 抽象类 /*** 抽象工厂方法 - 寄生式继承* @param {Class} subType 子类* @param {Class} superType 父类// 判断抽象工厂中是否有该抽象类 if(typeof VehicleFactory [ superType ] === 'function') {
【设计模式】工厂模式（Factory Pattern）
热门推荐
qq_27198345的博客
11-15 1万+
工厂模式
设计模式-工厂模式
m0_37715028的博客
06-01 6680
工厂模式定义：这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式、在工厂模式中，我们在创建对对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。简单来说，使用了c++多态的特性，将存在继承关系的类，通过一个工厂类创建对应的子类（派生类）对象。在项目复杂的情况下，可以便于子类对象的创建。工厂模式的实现方式可分为简单工厂模式、工厂方法模式、抽象工厂模式，每个实现方式都存在优和劣。具体的情况: 鞋厂可以指定生成耐克、阿迪达斯和李宁牌子的鞋子。哪个鞋炒的火爆，
C++ 工厂模式
最新发布
卤煮小鱼的博客
05-21 288
模式核心工厂数量创建对象数量举例简单工厂一个工厂用参数判断创建谁1 个通常 1 个工厂方法一个具体工厂创建一个具体产品多个通常 1 个抽象工厂一个具体工厂创建一整套产品多个多个。
设计模式详解之工厂模式
阿里技术
05-25 7033
本文将着眼于工厂模式，从简单工厂模式、工厂方法模式和抽象工厂模式出发，展开学习和深入探讨。
设计模式之工厂模式
weixin_47292529的博客
05-07 1835
工厂方法模式，又称工厂模式、多态工厂模式或虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类负责生成具体的对象抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口。
软件详细设计总复习（一）【太原理工大学】
m0_52861684的博客
05-20 8810
软件详细设计之创建型模式，持续更新。
设计模式--六种创建型模式
冯浩月
04-13 9624
前言   每几种模式之间都有一定的联系，从中发现它们的相同点和不同点，研究发生改变的节点，这就是本篇博客所要说明的创建型设计模式之间的联系。它们包括：简单工厂模式、单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。 创建型模式的基本理解 创建型模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。 一个类创建型模式使用继承改变被实例
Java 创建型设计模式详解
WenZhang的博客
08-15 2283
概念抽象工厂模式提供了一个接口，用于创建一系列相关或互相依赖的对象，而无需指定它们的具体类。它通常用于创建一组相关产品，如操作系统的不同界面风格。结构抽象工厂类（AbstractFactory）：声明创建一组相关产品的方法。具体工厂类（ConcreteFactory）：实现抽象工厂的方法，生成一系列具体产品。抽象产品类（AbstractProduct）：定义产品的接口。具体产品类（ConcreteProduct）：实现具体产品。示例代码// 抽象产品Avoid use();
【设计模式】创建型模式（单例模式，原型模式，简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式）
qq_44126342的博客
06-01 759
文章目录单例模式应用举例单例模式的特点单例模式的优点和缺点java实现单例模式懒汉式单例饿汉式单例测试原型模式原型模式的优缺点java实现原型模式测试工厂模式简单工厂模式优缺点工厂方法模式抽象方法模式java实现工厂模式简单工厂模式工厂方法模式抽象工厂模式建造者模式优缺点java实现建造者模式应用 单例模式 定义的类只有一个实例,不可以通过new关键字来获取对象,只可以通过公共的某个方法获取对象 应用举例 操作系统的文件系统 线程池 数据库连接池 web应用的配置对象 缓存 spring 在spri
java设计模式笔记-创建型模式
white_while的博客
11-01 830
创建型模式
常用设计模式总结：（一）创建型模式
不思量
09-23 360
文章目录创建型模式简单工厂模式(Simple Factory Pattern)别名模式动机模式定义模式结构模式应用优点缺点工厂方法模式(Factory Method Pattern)别名模式动机模式定义模式结构模式应用优点缺点抽象工厂模式(Abstract Factory)模式动机模式定义模式结构优点缺点工厂模式的退化建造者模式(Builder Pattern)模式动机模式定义模式结构实例优点缺点...
面经系列之 设计模式(创建型)
weixin_40824616的博客
01-04 847
设计模式创建型模式1 简单工厂模式（普通简单工厂，多方法简单工厂，静态简单工厂）1）模式定义2）类图3）代码示例4）优缺点5）适用场景2 工厂方法模式1）模式定义2）类图3）代码示例4）优缺点5）适用场景3）抽象工厂模式1）模式定义2）类图3）代码示例4）优缺点5）适用场景4）建造者模式 创建型模式 1 简单工厂模式（普通简单工厂，多方法简单工厂，静态简单工厂） 1）模式定义 在简单工厂模式中，...
Java设计模式1：创建型模式（工厂，单例等）
qq_40959750的博客
07-06 233
创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 简单工厂模式 和名字一样简单，非常简单，直接上代码吧： public class FoodFactory { public static Food makeFood(String name) { if (name.equals("noodle"
设计模式学习之路2----创建型模式详解
ccsu_deer
05-02 574
【目录】 设计模式学习之路1----设计模式的三大分类及六大原则 设计模式学习之路2----创建型模式详解 设计模式学习之路3----结构型模式详解上 设计模式学习之路4----结构型模式详解下 设计模式学习之路5----行为型模式详解上 设计模式学习之路6----行为型模式详解下 本博客专门介绍创建型模式 1、简单工厂模式 工厂模式提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 实例 我们先创建..
【学习笔记】软件设计模式（二）创建型模式
阿J的博客
12-12 540
软件设计模式之创建型模式文章目录总述抽象工厂模式概述结构优缺点建造者模式概述结构优缺点工厂方法模式概述结构优缺点原型模式概述结构优缺点单例模式概述结构优缺点 总述 创建型模式关注对象的创建过程。对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离，对用户隐藏了类的实例的创建细节。 创建型模式描述如何将对象的创建和使用分离，让用户在使用对象时无须关心对象的创建细节，从而降低系统的耦...
设计模式学习(1)-创建型模式
会写BUG
11-13 1008
基于C++代码的设计模式学习，主要整理了创建型模式、结构型模式以及行为型模式三类设计模式，同时练习UML类图的绘制
图说设计模式（二）
CWY_007的博客
08-09 548
创建型模式 关键之处是对类的实例化过程进行了抽象，将创建和对象的使用分裂，使得软件结构清晰，别人使用的时候，只需要知道使用接口，不需要知道具体实现细。包含的模式有简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。 简单工厂模式（simple factory pattern） 如果有一个基类有很多子类继承，这个时候我想根据不同的参数创建不同的子类实例，可以构建一个工厂类...
设计模式一：创建型模式
weixin_34206899的博客
05-13 166
知识储备： 1.接口：若干抽象方法的集合 　　作用：限制实现接口的类必须按照接口给定的调用方式实现这些方法；对高层模块隐藏了类的内部实现。 2.面向对象设计SOLID原则 开放封闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。 里氏替换原则：所有引用父类的地方必须能透明的使用其子类的对象。 依赖倒置原则：高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值