在面向对象的编程中，一般通过继承和虚函数来提供抽象能力，多态让程序在执行期，调用者只需要看到父类类型，而不需要关心继承的子类类型。举个例子: 比如有个游戏，里面的游戏的活动对象为动物，比如有老虎和猫，会对主人公进行攻击。那么可能会实现为如下:

代码如下:

class Animal
{public:virtual void Attack() = 0;
};class Tiger : public Animal
{public:virtual void Attack() { std::cout << "Tiger Attack!" << std::endl; };
};class Cat : public Animal
{public:virtual void Attack() { std::cout << "Cat Attack!" << std::endl; };
};

那如果在外面有个方法，并不需要关心具体的对象类型，只需要使用基类Animal的指针去操作对象, 利用多态机制变可以实现对具体对象类型的方法调用:

void Attack(Animal* pAnimal)
{pAnimal->Attack();
}

比如这个时候采用如下方法进行调用(忽略里面内存释放的问题):

 Animal* pAnimal = new Tiger;Attack(pAnimal);pAnimal = new Cat;Attack(pAnimal);

输出结果为:

Tiger Attack!
Cat Attack!

上面多态例子说明了在程序实现的时候只需要操控Animal，知道其方法即可操作继承自Animal的对象。那么也就是说:

继承自Animal的Cat和Tiger的不需要暴露给使用者
可以屏蔽Cat和Tiger的创建过程，不需要被调用者所关心

那么这个时候模块化和工厂设计模式可以对其进行实现:

比如将Animal, Cat, Tiger的实现都放进一个动态链接库的模块中，并且只暴露Animal的头文件给调用者
而工厂方法设计模式，可以使用一个工厂方法创建具体的对象，返回的时候只返回基类Animal的指针。

本文将先从简单工厂说起，然后再谈一谈工厂方法以及抽象工厂。

简单工厂

我相信这个是大家最常见的一种实现方法，如下:

class AnimalFactory
{public:enum class AnimalType{TIGER,CAT};static Animal* CreateAnimal(const AnimalType type){if (AnimalType::TIGER == type){return new Tiger;}else if (AnimalType::CAT == type){return new Cat;}return nullptr;}
};

调用方法如下:

Animal* pAnimal = AnimalFactory::CreateAnimal(AnimalFactory::AnimalType::TIGER);
Attack(pAnimal);
pAnimal = AnimalFactory::CreateAnimal(AnimalFactory::AnimalType::CAT);
Attack(pAnimal);

但是这种方式违背了软件开发原则的开闭原则(Open-Closed Principle, OCP)，如果你需要新增一个叫做Dog的对象，则需要在CreateAnimal方法中修改分支判断逻辑。简单来说这种扩展方式，破坏了原有的逻辑，扩展中可能对软件的原有的稳定性产生影响。

可能有些人是不能够容忍代码，但也有人认为这种书写方式比较简单。从我个人在工程实践经验，认为软件开发设计原则是有非常好的指导性意义，但是也并不是所有的代码一定要符合软件开发的设计原则。个人的理解大致如下:

工程实践中有时候为了代码完全遵循软件开发设计原则，反而是有负担的，比如过度设计问题，一来有些代码模块可能甚至几年都不会对其进行修改扩展了，二来当逻辑实现比较简单的时候，过度设计也会让代码维护的人阅读代码实际是更加费劲的。毕竟大多数人都只是普通的程序员。
往往可扩展的代码编写时间是更长的，但是压在程序员头上的还有软件开发时间，对于一般的程序员来说，在规定时间内，有质量的完成需求是第一位的，而这个时候很可能就不会完全照顾软件开发设计原则了。

如果要符合开闭原则，那么我们可以实现工厂方法模式，让我们一起来看看吧。

工厂方法

工厂方法的主要是通过继承一个AnimalFactory来实现具体的工厂，比如CatFatory主要负责生产Cat，而TigerFacotory主要负责生产Tiger，其类图如下：

代码如下:

class AnimalFactory
{public:virtual Animal* CreateAnimal() = 0;
};class CatFactory : public AnimalFactory
{public:virtual Animal* CreateAnimal(){return new Cat;}
};class TigerFactory : public AnimalFactory
{public:virtual Animal* CreateAnimal(){return new Tiger;}
};

调用方式如下代码:

AnimalFactory* pFactory = new TigerFactory;
Animal* pAnimal = pFactory->CreateAnimal();
Attack(pAnimal);pFactory = new CatFactory;
pAnimal = pFactory->CreateAnimal();
Attack(pAnimal);

可以发现工厂方法模式如果需要扩展一个新的动物类型，也可以对应扩展一个新的工厂，比如增加一个新的DogFactory继承AnimalFactory去生产Dog，从而符合开闭原则，更加安全的进行扩展。但是这种方式也可以看出来，每增加一个新的动物类型就得新增一个Fatory。个人对这种模式理解如下:

当这种动物类型创建并不是很繁琐的时候，采用这种方式相比较简单工程而言会繁琐一些；但是当初始化过程比较多的时候，用工厂方法模式方式扩展会显得更加清晰；
这种设计模式的本身实现是取消了条件判断的逻辑，但是其实是把这个条件判断任务交给了使用者去判断选择哪个工厂了。

抽象工厂

对于新手来说可能不太好理解抽象工厂模式，容易和工厂方法模式混淆起来。工厂方法模式中的每一个工厂是生产一个动物角色，而在抽象工厂中是生产一类动物角色的抽象。
一个动物角色比较好理解，就是我们上面的CatFactory生产Cat角色，而TigerFactory生产Tiger角色。
一类动物角色，我们可以理解在这个游戏中，这些动物角色的攻击性也分普通模式和困难模式。

那么我们首先要将Tiger分成SimpleModeTiger和HardModeTiger; Cat分为SimpleModeCat和HardModeCat。然后抽象工厂提供CreateAnimal的接口，继承的SimpleModeFactory可以生产简单模式的Cat角色和Tiger角色，继承的HardModeFactory可以生产困难模式的Cat角色和Tiger角色。

实现的代码如下所示：

#include <iostream>class Animal
{public:virtual void Attack() = 0;
};class AbstructTiger : public Animal
{public:virtual void Attack() = 0;
};class SimpleModeTiger : public AbstructTiger
{public:virtual void Attack()  { std::cout << "Tiger Simple Attack!" << std::endl; }
};class HardModeTiger : public AbstructTiger
{public:virtual void Attack()  { std::cout << "Tiger Hard Attack!" << std::endl; }
};class AbstructCat : public Animal
{public:virtual void Attack() = 0;
};class SimpleModeCat : public AbstructCat
{public:virtual void Attack()  { std::cout << "Cat Simple Attack!" << std::endl; }
};class HardModeCat : public AbstructCat
{public:virtual void Attack()  { std::cout << "Cat Hard Attack!" << std::endl; }
};enum class AnimalType
{TIGER,CAT
};class AbscractAnimalFactory
{public:virtual Animal* CreateAnimal(const AnimalType type) = 0;
};class SimpleModeAnimalFactory : public AbscractAnimalFactory
{public:virtual Animal* CreateAnimal(const AnimalType type){if (AnimalType::TIGER == type){return new SimpleModeTiger;}else if (AnimalType::CAT == type){return new SimpleModeCat;}return nullptr;}
};class HardModeAnimalFactory : public AbscractAnimalFactory
{public:virtual Animal* CreateAnimal(const AnimalType type){if (AnimalType::TIGER == type){return new HardModeTiger;}else if (AnimalType::CAT == type){return new HardModeCat;}return nullptr;}
};void Attack(Animal* pAnimal)
{pAnimal->Attack();
}int main()
{//简单模式AbscractAnimalFactory* pFactory = new SimpleModeAnimalFactory;Animal* pAnimal = pFactory->CreateAnimal(AnimalType::TIGER);Attack(pAnimal);pAnimal = pFactory->CreateAnimal(AnimalType::CAT);Attack(pAnimal);//困难模式pFactory = new HardModeAnimalFactory;pAnimal = pFactory->CreateAnimal(AnimalType::TIGER);Attack(pAnimal);pAnimal = pFactory->CreateAnimal(AnimalType::CAT);Attack(pAnimal);
}

为了让结构简单便于读者理解抽象工厂模式，以及和工厂方法模式的区别，上面的SimpleModeFactory和HardModeFactory用的是简单工厂的形式实现的，如果需要符合开闭原则，可以再对SimpleModeFactory和HardModeFactory进行工厂方法的实现。可以想象如果抽象工厂再加上工厂方法这个类的结构是有多么的庞大，而且这还仅仅只是两个游戏角色的描述。所以笔者认为在做工程实践的时候，尽量不要做过度设计，有时候反而不利于代码阅读，修改也未必简单。自己要权衡好工程和理论的平衡点。

参考

<<C++设计新思维>>中的两个章节对象工厂和抽象工厂
秦小波的<<设计模式之禅>>
Does the Factory Pattern violate the Open/Closed Principle?

设计模式之简单工厂，工厂方法和抽象工厂相关推荐

设计模式：简单工厂、工厂方法、抽象工厂之小结与区别
简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式.其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性. 本文是本人对这三种模式学习后的一个小结以及对他 ...
【设计模式】简单工厂模式+工厂方法模式+抽象工厂模式
前提导论故事不采用工厂模式简单工厂模式工厂方法模式故事抽象工厂模式故事结局前提导论为了学习设计模式时便于理解,我将用基于农夫和他的村子与森林为背景环境,讲一个故事时,阐述一个设计模式 ...
【设计模式实战】简单工厂、工厂方法、抽象工厂：原理篇
小明开发的应用,经常要从XML或者Asset中读取省市区数据. 小明是这样写的: public abstract class IOHandler {/*** 添加*/public abstract v ...
研磨23种大话设计模式------简单工厂模式 + 工厂方法模式 + 抽象工厂模式
大家好,我是一位在java学习圈中不愿意透露姓名并苟且偷生的小学员,如果文章有错误之处,还望海涵,欢迎多多指正如果你从本文 get 到有用的干货知识,请帮忙点个赞呗,据说点赞的都拿到了offer 简 ...
【设计模式】Unity3D 简单工厂、工厂(方法)、抽象工厂模式
创建型模式-工厂三兄弟提示:个人学习总结,如有错误,敬请指正文章目录创建型模式---工厂三兄弟一.简单工厂模式 1.简单工厂模式是什么? 2.UML图 3.实现方式二.工厂(方法)模式 1. ...
设计模式学习笔记（三）简单工厂、工厂方法和抽象工厂之间的区别
设计模式中的工厂模式(Factory Design pattern)是一个比较常用的创建型设计模式,其中可以细分为三种:简单工厂(Simple Factory).工厂方法(Factory Method ...
设计模式学习笔记（三）工厂模式中的简单工厂、工厂方法和抽象工厂模式之间的区别
设计模式中的工厂模式(Factory Design pattern)是一个比较常用的创建型设计模式,其中可以细分为三种:简单工厂(Simple Factory).工厂方法(Factory Method ...
2.5万字详解23种设计模式—创建型模式（简单工厂、工厂方法、抽象工厂、单例-多线程安全详解、建造者、原型）的详细解读、UML类图
本文简述了各大设计模式,并通过UML和代码详细说明.本文大约共 2.5W 字,建议收藏.下方是本文的目录: 一.设计模式的认识二.设计模式的分类根据其目的根据范围三.设计模式的优点四.设计模 ...
Android工厂设计模式(简单工厂，工厂方法，抽象工厂，BitmapFactory简单工厂分析，Retrofit抽象工厂分析)
文章目录创建型设计模式(简单工厂,工厂方法,抽象工厂) 一.简单工厂模式引出简单工厂模式二.工厂方法模式三.抽象工厂模式 Android源码中用到的工厂模式举例一.BitmapFactory ...
设计模式——简单工厂、工厂方法和抽象工厂的区别与联系
前言创建型模式中,常用的有工厂方法模式和抽象工厂模式,平时实践还包括简单工厂模式,虽然简单工厂模式不在23种设计模式中. 为了区分以上几种设计模式的差别,通过以下几个例子介绍这几种模式的使用场景以及 ...

设计模式之简单工厂，工厂方法和抽象工厂

简单工厂

工厂方法

抽象工厂

参考

设计模式之简单工厂，工厂方法和抽象工厂相关推荐

最新文章

热门文章