关键词：
简单工厂模式
简单工厂模式并不属于GoF的23种设计模式。
那么为什么我要用工厂模式呢？请看下面的一段程序。
#include <iostream> using namespace std; class Fruit public: Fruit(string name) this-‐>name = name; if (name == "apple") //代表苹果 else if (name == "banana") //2 代表⾹香蕉 else if (name == "pear") //3 代表鸭梨 void getName() if (name == "apple") cout << "我是苹果" << endl; else if (name == "banana") cout << "我是⾹香蕉" << endl; else if (name == "pear") cout << "我是鸭梨" << endl; private: int kind; string name; ; int main(void) Fruit apple = Fruit("apple"); Fruit banana = Fruit("banana"); Fruit pear = Fruit("pear"); apple.getName(); banana.getName(); pear.getName(); return 0;
不难看出，Fruit类是一个“巨大的”类，在该类的设计中存在如下几个问题：
(1) 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，
代码越长，阅读难度、维护难度和测试难度也越大；而且大量条件语句的存在
还将影响系统的性能，程序在执行过程中需要做大量的条件判断。
(2) Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水
果对象的初始化代码和显示代码集中在一个类中实现，违反了“单一职责原
则”，不利于类的重用和维护；
(3) 当需要增加新类型的水果时，必须修改Fruit类的源代码，违反了“开
闭原则”。
模式中的角色和职责
工厂（Factory）角色：简单工厂模式的核心，它负责实现创建所有实例
的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
抽象产品（AbstractProduct）角色：简单工厂模式所创建的所有对象的
父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：简单工厂模式所创建的具体实例
对象。
#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; ; /* 现在添加一个鸭梨，那么只需要再创建一个鸭梨类 来实现抽象水果类即可。 */ ?20 class Pear :public Fruit public: virtual void getName() cout << "我是鸭梨" << endl; ; class Factory public : Fruit * createFruit(string name) if (name == "apple") return new Apple; else if (name == "banana") return new Banana; /* 但是，当我们创建鸭梨的时候，Factory却变得越加庞大了 这样就不符合了开闭原则。 */ else if (name == "pear") return new Pear; ; int main(void) Factory * factory = new Factory; Fruit * fruit = NULL; /* 我们用工厂创建一个具体水果类，返回抽象类指针 那么这样就会发生多态。 此时抽象类指针指向了具体的子类，那么调用抽象方法 就会调用子类的实现方法。 */ fruit = factory-‐>createFruit("apple"); fruit-‐>getName(); delete fruit; fruit = NULL; fruit = factory-‐>createFruit("banana"); fruit-‐>getName(); delete fruit; fruit = NULL; fruit = factory-‐>createFruit("pear"); fruit-‐>getName(); delete fruit; fruit = NULL; delete factory; return 0;
优点：
1. 实现了对象创建和使用的分离。
2. 不需要记住具体类名，记住参数即可，减少使用者记忆量。
缺点：
1. 对工厂类职责过重，一旦不能工作，系统受到影响。
2. 增加系统中类的个数，复杂度和理解度增加。
3. 违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。
适用场景
1. 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂
方法中的业务逻辑太过复杂。
2. 客户端只知道传入工厂类的参数，对于如何创建对象并不关心。
工厂方法模式
工厂方法模式中的角色和职责
抽象工厂（Abstract Factory）角色：工厂方法模式的核心，任何工厂类
都必须实现这个接口。
工厂（Concrete Factory）角色：具体工厂类是抽象工厂的一个实现，
负责实例化产品对象。
抽象产品（Abstract Product）角色：工厂方法模式所创建的所有对象
的父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：工厂方法模式所创建的具体实例对象。
工厂方法模式的案例
#include <iostream> using namespace std; /* 创建一个水果抽象类，供具体的水果实现，和抽象工厂返回 */ class Fruit public: virtual void getName() = 0; ; /* 创建一个工厂抽象类，供具体的水果工厂实现，并且返回抽象水果类 */ class AbstractFactory public: virtual Fruit * createFruit() = 0; ; class Apple :public Fruit public: virtual void getName() cout << "我是苹果" << endl; ; class Banana : public Fruit public: virtual void getName() cout << "我是⾹香蕉" << endl; ; //实现了抽象工厂，并且返回⼀一个抽象水果指针 class AppleFactory :public AbstractFactory public: virtual Fruit * createFruit() return new Apple; ; class BananaFactory : public AbstractFactory public: virtual Fruit *createFruit() return new Banana; ; /* 此时，如果要想添加一种 鸭梨 那么 不需要再去修改其中任何一个类， 而只需要实现一个鸭梨工厂，和一个鸭梨具体类 */ class Pear : public Fruit public: virtual void getName() cout << "我是鸭梨" << endl; ; 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; /* ?25 抽象类指针，完成Banana 业务 */ abFactory = new BananaFactory; fruit = abFactory-‐>createFruit(); fruit-‐>getName(); delete abFactory; delete fruit; /* 抽象类指针，完成Banana 业务 */ abFactory = new PearFactory; fruit = abFactory-‐>createFruit(); fruit-‐>getName(); delete abFactory; delete fruit; return 0;
优点：
1. 不需要记住具体类名，甚至连具体参数都不用记忆。
2. 实现了对象创建和使用的分离。
3. 系统的可扩展性也就变得非常好，无需修改接口和原类。
缺点：
1. 增加系统中类的个数，复杂度和理解度增加。
2. 增加了系统的抽象性和理解难度。
适用场景
1. 客户端不知道它所需要的对象的类。
2. 抽象工厂类通过其子类来指定创建哪个对象。
抽象工厂模式
工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责
太重的问题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致
系统中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑将一
些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是我们本
文将要学习的抽象工厂模式的基本思想。
抽象工厂（Abstract Factory）角色：它声明了一组用于创建一族产品的
方法，每一个方法对应一种产品。
具体工厂（Concrete Factory）角色：它实现了在抽象工厂中声明的创
建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品
都位于某个产品等级结构中。
抽象产品（Abstract Product）角色：它为每种产品声明接口，在抽象
产品中声明了产品所具有的业务方法。
具体产品（Concrete Product）角色：它定义具体工厂生产的具体产品
对象，实现抽象产品接口中声明的业务方法。
抽象工厂模式案例
#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 ChinaBanana : public AbstractBanana public : virtual void getName() cout << "中国⾹香蕉" << endl; ; class USABanana : public AbstractBanana public: virtual void getName() cout << "美国⾹香蕉" << endl; ; //抽象的工厂类，供具体产品族的工厂实现 class AbstractFactory public: virtual AbstractApple * createApple() = 0; virtual AbstractBanana * createBanana() = 0; ; class ChinaFactory : public AbstractFactory public: ?30 virtual AbstractApple * createApple() return new ChinaApple; virtual AbstractBanana * createBanana() return new ChinaBanana; ; class USAFactory : public AbstractFactory public: virtual AbstractApple * createApple() return new USAApple; virtual AbstractBanana * createBanana() return new USABanana; ; int main(void) //现在准备 要一个 中国的苹果，中国的香蕉 AbstractApple *apple = NULL; AbstractBanana *banana = NULL; AbstractFactory *factory = NULL; factory = new ChinaFactory; //中国的苹果 apple = factory-‐>createApple(); //中国的香蕉 banana = factory-‐>createBanana(); apple-‐>getName(); banana-‐>getName(); delete apple; delete banana; delete factory; return 0;
1. 拥有工厂方法模式的优点
2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端
始终只使用同一个产品族中的对象。
3 增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
1. 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需
要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”
适用场景
(1) 系统中有多于一个的产品族。而每次只使用其中某一产品族。可以通过
配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产
品族。
(2) 产品等级结构稳定。设计完成之后，不会向系统中增加新的产品等级结
构或者删除已有的产品等级结构。
单例模式
保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局
访问方法。
（GoF给出单例模式的定义）
三个要点：
一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。
模式中的角色和职责
Singleton（单例）：在单例类的内部实现只生成一个实例，同时它提供
一个静态的getInstance()工厂方法，让客户可以访问它的唯一实例；为了防止
在外部对其实例化，将其构造函数设计为私有；在单例类内部定义了一个
Singleton类型的静态对象，作为外部共享的唯一实例。
单例模式的使用步骤：
a) 构造函数私有化。
b) 提供一个全局的静态方法（全局访问点）来获取单例对象。
c) 在类中定义一个静态指针，指向本类的变量的静态变量指针 。
#include <iostream> using namespace std; /* 懒汉模式 */ class Singelton public: /* 对外提供⼀一个全局静态方法 */ static Singelton * getInstance() /* 懒汉式: 在调用全局静态方法，获取单例的时候， 再进行创建。懒汉式的单例创建在程序的执行中进行。 */ if (instance == NULL)
//线程中加锁 instance = new Singelton;
//解锁 m_count++; return instance; int getCount() return m_count; private: /* 构造函数私有化 */ Singelton() instance = NULL; m_count = 0; cout << "构造函数 singelton() 执行" << endl; /* 在类中定义一个静态指针，指向本类的变量的静态变量指针 */ static Singelton *instance; static int m_count; ; /* 对静态变量的初始化，要放在类的外部， 即，放在全局位置上。 */ Singelton * Singelton::instance = NULL; int Singelton::m_count = 0; /* 饿汉模式 */ class Singelton2 public: static Singelton2* getInstance() m_count++; return instance; int getCount() return m_count; private: Singelton2() instance = NULL; m_count = 0; static Singelton2 * instance; static int m_count; ; /* 饿汉式不是在全局静态方法中创建， 而是不管你创不创建实例，我在声明的 时候就创建出来， 饿汉式的单例，是在编译的时候就已经创建好了。 */ Singelton2 * Singelton2::instance = new Singelton2; int Singelton2::m_count = 0; int main(void) Singelton * singer = Singelton::getInstance(); cout << singer-‐>getCount() << endl; Singelton * singer2 = Singelton::getInstance(); cout << singer2-‐>getCount() << endl; if (singer == singer2) cout << "二者是同⼀一个实例" << endl; else cout << "二者不是同一个实例" << endl; cout << "-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ 以下 是 饿汉式 -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" << endl; Singelton2 * singer3 = Singelton2::getInstance(); cout << singer3-‐>getCount() << endl; Singelton2 * singer4 = Singelton2::getInstance(); cout << singer4-‐>getCount() << endl; if (singer3 == singer4) cout << "⼆二者是同⼀一个实例" << endl; else cout << "⼆二者不是同⼀一个实例" << endl; return 0;
思考：
当单例模式中的懒汉模式遇见多线程，改怎么办？加锁
单例模式的优缺点
优点：
(1) 单例模式提供了对唯一实例的受控访问。
(2) 节约系统资源。由于在系统内存中只存在一个对象。
缺点：
(1) 扩展略难。单例模式中没有抽象层。
(2) 单例类的职责过重。
3.4.4 适用场景
(1) 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器
或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。
(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问
点，不能通过其他途径访问该实例。
代理模式
Proxy模式又叫做代理模式，是构造型的设计模式之一，它可以为其他对象
提供一种代理（Proxy）以控制对这个对象的访问。
所谓代理，是指具有与代理元（被代理的对象）具有相同的接口的类，
客户端必须通过代理与被代理的目标类交互，而代理一般在交互的过程中（交
互前后），进行某些特别的处理。
模式中的角色和职责
subject（抽象主题角色）：真实主题与代理主题的共同接口。
RealSubject（真实主题角色）：定义了代理角色所代表的真实对象。
Proxy（代理主题角色）：含有对真实主题角色的引用，代理角色通常在
将客户端调用传递给真是主题对象之前或者之后执行某些操作，而不是单纯返
回真实的对象。
4.1.2 代理模式的案例
#include <iostream>
#include <string>
using namespace std;
class Item
public:
Item(string kind, bool fact)
this-‐>kind = kind;
this-‐>fact = fact;
//物品类别
string kind;
//是否真伪？
bool fact;
;
/*
抽象一种购物⽅方式，具有买功能。
*/
class Shopping
public:
virtual void buy(Item & item) = 0;
;
/*
基于抽象类，实现一种具体的购物模式，去韩国购物
*/
class KoreaShopping : public Shopping
public:
virtual void buy(Item & item)
cout << "去韩国进⾏行了购物, 买了" << item.kind << endl;
;
/*
基于抽象类，实现⼀一种具体的购物模式，去美国购物
*/
class USAShopping : public Shopping
public:
virtual void buy(Item & item)
cout << "去美国进⾏行了购物, 买了" << item.kind << endl;
;
/*
基于抽象类，实现⼀一种具体的购物模式，去⾮非洲购物
*/
class AfrikaShopping : public Shopping
public:
virtual void buy(Item & item)
cout << "去非洲进行了购物, 买了" << item.kind << endl;
;
/*
有一个海外代购 代理，同样实现了购物模式，
而且增加了 办理护照 和 货物海关安检等 具体业务。
*/
class OverseasProxy : public Shopping
public:
OverseasProxy(Shopping * shopping)
this-‐>shopMode = shopping;
~OverseasProxy()
delete this-‐>shopMode;
//调⽤用 真实 购物模式
virtual void buy(Item & item)
if (distinguish(item) == true)
this-‐>shopMode-‐>buy(item);
check(item);
else
cout << "发现伪货["<<item.kind<<"],不能购买" << endl;
//辨别物品真伪
bool distinguish(Item & item)
cout << "对物品[" <<item.kind<<"]辨别真伪. " << endl;
return item.fact;
//海关安检
void check(Item &item)
cout << "通过海关安检，带回国内" << endl;
private:
Shopping * shopMode;
;
int main(void)
// 有⼏几种类型的物品
Item t1("化妆品", true);
Item t2("CET4证书", false);
Item t3("addass运动鞋", true);
Shopping *shopping = NULL;
OverseasProxy * proxy = NULL;
//现在想要买这⼏几种物品
//1. 去韩国买 化妆品
proxy = new OverseasProxy(new KoreaShopping);
proxy-‐>buy(t1);
delete proxy;
//2 去美国买CET4 证书
proxy = new OverseasProxy(new USAShopping);
proxy-‐>buy(t2);
delete proxy;
//3 去⾮非洲买addass
proxy = new OverseasProxy(new AfrikaShopping);
proxy-‐>buy(t3);
delete proxy;
return 0;
代理模式的种类
(1) 远程代理(Remote Proxy)：为一个位于不同的地址空间的对象提供一
个本地的代理对象，这个不同的地址空间可以是在同一台主机中，也可是在另
一台主机中，远程代理又称为大使(Ambassador)。
(2) 虚拟代理(Virtual Proxy)：如果需要创建一个资源消耗较大的对象，先
创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建。
(3) 保护代理(Protect Proxy)：控制对一个对象的访问，可以给不同的用
户提供不同级别的使用权限。
(4) 缓冲代理(Cache Proxy)：为某一个目标操作的结果提供临时的存储空
间，以便多个客户端可以共享这些结果。
(5) 智能引用代理(Smart Reference Proxy)：当一个对象被引用时，提供
一些额外的操作，例如将对象被调用的次数记录下来等。
代理模式的优缺点
优点：
(1) 能够协调调用者和被调用者，在一定程度上降低了系统的耦合度。
(2) 客户端可以针对抽象主题角色进行编程，增加和更换代理类无须修改源
代码，符合开闭原则，系统具有较好的灵活性和可扩展性。
缺点：
(1) 代理实现较为复杂。
适用场景
为其他对象提供一种代理以控制对这个对象的访问。
装饰模式
装饰模式(Decorator Pattern)：动态地给一个对象增加一些额外的职责，
就增加对象功能来说，装饰模式比生成子类实现更为灵活。装饰模式是一种对
象结构型模式。
装饰模式中的角色和职责
Component（抽象构件）：它是具体构件和抽象装饰类的共同父类，声
明了在具体构件中实现的业务方法，它的引入可以使客户端以一致的方式处理
未被装饰的对象以及装饰之后的对象，实现客户端的透明操作。
ConcreteComponent（具体构件）：它是抽象构件类的子类，用于定
义具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额
外的职责（方法）。
Decorator（抽象装饰类）：它也是抽象构件类的子类，用于给具体构件
增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引
用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，
以达到装饰的目的。
ConcreteDecorator（具体装饰类）：它是抽象装饰类的子类，负责向
构件添加新的职责。每一个具体装饰类都定义了一些新的行为，它可以调用在
抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。
4.2.2 装饰器案例
#include <iostream> #include <string> using namespace std; 查看详情gof三种工厂模式~
文章目录工厂模式1简单工厂模式1.1什么是简单工厂模式1.2使用简单工厂模式与不使用简单工厂的对比1.2.1不使用简单工厂模式1.2.2使用简单工厂模式1.3简单工厂的例子... 查看详情
简单工厂工厂抽象工厂
设计模式(2)--简单工厂模式设计模式(3)--工厂方法模式设计模式(4)--抽象工厂模式设计模式之工厂模式--简单工厂、工厂、抽象工厂 查看详情
工厂模式抽象工厂模式策略模式
...做静态工厂方法（StaticFactoryMethod）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家 查看详情
设计模式11：抽象工厂模式
阅读材料：http://baike.xsoftlab.net/view/209.html#3_2抽象工程模式解决的问题：当前有一套产品，称为A；另一套产品称为B。客户端代码需要在两套产品中切换。抽象工厂模式相当于在简单工厂模式之上又抽象了一层，使得客户端代码在... 查看详情
简单工厂工厂方法抽象工厂区别
设计模式：简单工厂、工厂方法、抽象工厂之小结与区别 大话设计模式之简单工厂模式、抽象工厂模式及工厂方法模式的比较 抽象工厂模式-与-工厂方法模式区别 在简单工厂模式下，工人要想到种植萝卜还是白菜，... 查看详情
简单工厂模式工厂方法模式抽象工厂模式用图理解
1.简单工厂模式 2.工厂方法模式 3.抽象工厂模式例子1 例子2 查看详情
设计模式——抽象工厂模式(代码片段)
设计模式（七）——抽象工厂模式在设计模式（五）——工厂方法模式和设计模式（六）——JDK中的那些工厂方法中介绍了工厂方法模式。本文将介绍另外一种工厂模式——抽象工厂模式。工厂模式的简单回顾在介绍了简单工厂... 查看详情
简单工厂，抽象工厂，工厂模式三者的对照
...厂模式可能就没那么easy了。所以我查看了很多资料以及设计模式关于工厂模式的介绍，以下来总结一下。前言简单工厂，抽象工厂。工厂模式都属 查看详情
嵌入式c语言设计模式---抽象工厂模式
...模式里面的两种：简单工厂模式和工厂方法模式，这两种设计模式都有其各自的优缺点和适用场景。本篇文章继续讲述最后一种工厂模式，抽象工厂模式。（AbstractFactoryPattern）抽象工厂模式，是一种为访问类提供一个创建一组... 查看详情
简单工厂模式工厂模式抽象工厂模式
...例子中鼠标，键盘，耳麦为产品，惠普，戴尔为工厂 简单工厂模式简单工厂模式不是23种里的一种，简而言之，就是有一个专门生产某个产品的类。比如下图中的鼠标工厂，专业生产鼠标，给参数0，生产戴尔鼠标，给参数1... 查看详情
java设计模式——工厂模式简单工厂模式工厂方法模式抽象工厂模式(代码片段)
目录简单工厂模式传统方式简单工厂模式静态工厂模式工厂方法模式抽象工厂模式工厂模式JDK-Calendar源码分析工厂模式小结简单工厂模式 看一个具体的需求看一个披萨的项目:要便于披萨种类的扩展，要便于维护（1）... 查看详情
设计模式之一（简单工厂模式）
简单工厂模式说先说一下我们熟悉的23中设计模式划分：总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式... 查看详情
简单工厂模式&工厂方法模式&抽象工厂模式的区别(代码片段)
...为简略。这里重新分析分析三者的区别，工厂模式是java设计模式中比较简单的一个设计模式，但很多地方都用到了工厂模式，（如解析xml中，jdbc连接数据库等）利用好工厂模式对程序的设计很有用处。工厂模式在一些设计模式... 查看详情
简单工厂模式，工厂模式，抽象工厂模式(代码片段)
...忘得快，尽快复习下喽。。。工厂模式有三种，简单工厂模式，工厂模式，抽象工厂模式1.简单工厂模式：简单将产品的制造进行封装，不分类别只是简单的工厂和产品的依赖关系 具体要素：工厂... 查看详情
设计模式-简单工厂--工厂模式--抽象模式
1、简单工厂模式packagecom.bjsxt.factory.simplefactory;publicinterfaceCar{voidrun();}packagecom.bjsxt.factory.simplefactory;publicclassAudiimplementsCar{@Overridepublicvoidrun(){System.out.println("奥迪再跑 查看详情
关于简单工厂模式工厂方法模式和抽象工厂模式的解析(代码片段)
文章目录前言简单工厂模式创建ICourse接口实现ICourse接口创建工厂类测试工厂方法模式创建课程类接口创建具体实现课程类创建工厂类接口创建具体工厂类测试抽象工厂模式创建笔记和视频接口具体JAVA的笔记和视频创建工厂类接... 查看详情
工厂模式抽象工厂模式
昨天我们说到了简单工厂模式，今天我们来说说工厂模式，还有抽象工厂模式。工厂模式，顾名思义，就是在简单工厂模式的基础上继续优化，前面的简单模式当数量多时要改的地方很多，而且比较分散，修改起来比较麻烦，那... 查看详情