设计模式（一）：创建型模式之工厂（😁）

架构

❤简单工厂模式

定义

简单工厂模式(Simple Factory Pattern)：专门定义一个类（工厂类）来负责创建其他类的实例。可以根据创建方法的参数来返回不同类的实例，被创建的实例通常都具有共同的父类。

简单工厂模式又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。

适用场景

如果我们希望将一些为数不多的类似的对象的创建和他们的创建细节分离开，也不需要知道对象的具体类型，可以使用简单工厂模式。

举个形象点的例子：在前端开发中，常常会使用外观各式各样的按钮：比如有的按钮有圆角，有的按钮有阴影，有的按钮有边框，有的按钮无边框等等。但是因为同一种样式的按钮可以出现在项目的很多地方，所以如果在每个地方都把创建按钮的逻辑写一遍的话显然是会造成代码的重复（而且由于业务的原因有的按钮的创建逻辑能比较复杂，代码量大）。

那么为了避免重复代码的产生，我们可以将这些创建按钮的逻辑都放在一个“工厂”里面，让这个工厂来根据你的需求（传入的参数）来创建对应的按钮并返回给你。这样一来，同样类型的按钮在多个地方使用的时候，就可以只给这个工厂传入其对应的参数并拿到返回的按钮即可。

成员与类图

成员

简单工厂模式的结构比较简单，一共只有三个成员：

• 工厂（Factory）：工厂负责实现创建所有产品实例的逻辑
• 抽象产品（Product）：抽象产品是工厂所创建的所有产品对象的父类，负责声明所有产品实例所共有的公共接口。
• 具体产品（Concrete Product）：具体产品是工厂所创建的所有产品对象类，它以自己的方式来实现其共同父类声明的接口。

模式类图

代码示例

场景概述

举一个店铺售卖不同品牌手机的例子：店铺，即客户端类向手机工厂购进手机售卖。

该场景可以使用简单工厂的角色来设计：

• 抽象产品：Phone，是所有具体产品类的父类，提供一个公共接口packaging表示手机的装箱并送到店铺。
• 具体产品：不同品牌的手机，iPhone手机类（IPhone），小米手机类（MIPhone），华为手机类（HWPhone）。
• 工厂：PhoneFactory根据不同的参数来创建不同的手机。
• 客户端类：店铺类Store负责售卖手机。

代码实现

抽象产品类Phone：

//================== Phone.h ==================
@interface Phone : NSObject
//package to store
- (void)packaging;
@end

具体产品类:

//================== IPhone ==================
@interface IPhone : Phone
@end
@implementation IPhone
- (void)packaging{
    NSLog(@"IPhone has been packaged");
}
@end
//================== MIPhone ==================
@interface MIPhone : Phone
@end
@implementation MIPhone
- (void)packaging{
    NSLog(@"MIPhone has been packaged");
}
@end
//================== HWPhone.h ==================
@interface HWPhone : Phone
@end
@implementation HWPhone
- (void)packaging{
    NSLog(@"HUAWEI Phone has been packaged");
}
@end

以上是抽象产品类以及它的三个子类：苹果手机类，小米手机类和华为手机类。 下面看一下工厂类 PhoneFactory：

//================== PhoneFactory.h ==================
@interface PhoneFactory : NSObject
+ (Phone *)createPhoneWithTag:(NSString *)tag;
@end
//================== PhoneFactory.m ==================
#import "IPhone.h"
#import "MIPhone.h"
#import "HWPhone.h"
@implementation PhoneFactory
+ (Phone *)createPhoneWithTag:(NSString *)tag{
    if ([tag isEqualToString:@"i"]) {
        IPhone *iphone = [[IPhone alloc] init];
        return iphone;
    }else if ([tag isEqualToString:@"MI"]){
        MIPhone *miPhone = [[MIPhone alloc] init];
        return miPhone;
    }else if ([tag isEqualToString:@"HW"]){
        HWPhone *hwPhone = [[HWPhone alloc] init];
        return hwPhone;
    }else{
        return nil;
    }
}
@end

工厂类向外部（客户端）提供了一个创造手机的接口createPhoneWithTag:，根据传入参数的不同可以返回不同的具体产品类。因此客户端只需要知道它所需要的产品所对应的参数即可获得对应的产品了。

在本例中，我们声明了店铺类 Store为客户端类：

//================== Store.h ==================
#import "Phone.h"
@interface Store : NSObject
- (void)sellPhone:(Phone *)phone;
@end
//================== Store.m ==================
@implementation Store
- (void)sellPhone:(Phone *)phone{
    NSLog(@"Store begins to sell phone:%@",[phone class]);
}
@end

客户端类声明了一个售卖手机的接口sellPhone:。表示它可以售卖作为参数所传入的手机。

最后我们用代码模拟一下这个实际场景：

//================== Using by client ==================
//1. A phone store  wants to sell iPhone
Store *phoneStore = [[Store alloc] init];
//2. create phone
Phone *iPhone = [PhoneFactory  createPhoneWithTag:@"i"];
//3. package phone to store
[iphone packaging];
//4. store sells phone after receving it
[phoneStore sellPhone:iphone];

上面代码的解读：

1.最开始实例化一个商店，商店打算卖苹果手机
2.商店委托工厂给他制作一台iPhone手机，传入对应的字段i。
3.手机生产好以后打包送到商店
4.商店售卖手机

在这里我们需要注意的是：商店从工厂拿到手机不需要了解手机制作的过程，只需要知道它要工厂做的是手机（只知道Phone类即可），和需要给工厂类传入它所需手机所对应的参数即可（这里的iPhone手机对应的参数就是i）。

代码对应的类图

代码示例二

场景概述

比如我们的一个APP中的一个页面是用TableViewCell来展示的，但是网络接口中提供的数据是A、B、C三种不同类型的数据，A为纯文字，B为文字+图片，C为纯图片。并且这三种类型的数据是按不规律的形式出现的，那么我们在利用model为cell赋值的时候，cell的展现形式要与model类的数据形式相匹配，要注册不同类型的的cell用来展现然后再进行类型判断。

简单工厂模式的原理就是只创建一个model类和cell类，然后以这两个类为父类创建不同的子类，在子类中根据接口数据分配的类型重写model的数据cell的布局等；重写model和cell父类的初始化方法，使用不用的子类的类型来创建父类，总结起来就是一句话：根据不同需求生产不同的产品。

代码实现

model：

//.h文件
#import <Foundation/Foundation.h>
@interface Model : NSObject
+(instancetype)initWithDictionary:(NSDictionary *)dictionary;
@end
//.m文件
#import "Model.h"
#import "First.h"
#import "Second.h"
#import "Third.h"
@implementation Model
//根据字典内提供的数据分别创建出对应的model来获取数据
+(instancetype)initWithDictionary:(NSDictionary *)dictionary{
    //先使用父类创建对象；
    Model *rootModel = nil;
    //根据字典中的key对应的数据初始化不同的子类对象并将其返回给父类
    if ([dictionary[@"tag"] isEqualToString:@"1"]) {
        rootModel = [[First alloc]init];
    }else if ([dictionary[@"tag"] isEqualToString:@"2"]){
        rootModel = [[Second alloc]init];
    }else if ([dictionary[@"tag"] isEqualToString:@"3"]){
        rootModel = [[Third alloc]init];
    }
    [rootModel setValuesForKeysWithDictionary:dictionary];
    return rootModel;
}
-(void)setValue:(id)value forUndefinedKey:(NSString *)key
{
}
@end

cell的父类：

//.h文件中
#import <UIKit/UIKit.h>
@class Model;
@interface MyTableViewCell : UITableViewCell
//在父类中声明出一个model类对象，在它的子类中重写set方法，在set方法内部去实现赋值操作
@property(nonatomic,strong) Model *model;
//根据不同类型的model创建不同的cell
+(instancetype)initWithModel:(Model *)model;
@end
//.m文件中
#import "MyTableViewCell.h"
@implementation MyTableViewCell
+(instancetype)initWithModel:(Model *)model{
    //根据OC函数获取model类名并将其转化为OC字符串
    NSString *modelName = [NSString stringWithUTF8String:object_getClassName(model)];
    //使用model的类名拼接一个"cell"来获取到cell类名
    NSString *cellName = [modelName stringByAppendingString:@"TableViewCell"];
    //根据提供的cellName来给予不同cell所对应的'cell子类'初始化一个cell对象返回给我们的父类对象
    //唯一标示符可以使我们所提供的model来给与不同cell所对应的标示符来重用
    MyTableViewCell *cell = [[NSClassFromString(cellName) alloc]initWithStyle:(UITableViewCellStyleDefault) reuseIdentifier:modelName];
    return cell;
}
@end

使用：

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
    //根据indexPath.row获取对应的model
    Model *model = [self.dataArray objectAtIndex:indexPath.row];
    //根据取出的modle获取对应的类名
    NSString *modelName = [NSString stringWithUTF8String:object_getClassName(model)];
    //根据不同的唯一标识重用不同的cell
    MyTableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:modelName];
    if (cell == nil) {
        //根据我们每行提供的model创建出对应的cell（根据不同的需求生产不同的产品）
        cell = [MyTableViewCell initWithModel:model];
    }
    //赋值
    [cell setModel:model];
    return cell;
}

优点

• 客户端只需要给工厂类传入一个正确的（约定好的）参数，就可以获取你所需要的对象，而不需要知道其创建细节，一定程度上减少系统的耦合。
• 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，减少开发者的记忆成本。

缺点

• 如果业务上添加新产品的话，就需要修改工厂类原有的判断逻辑，这其实是违背了开闭原则的。
  在产品类型较多时，有可能造成工厂逻辑过于复杂。所以简单工厂模式比较适合产品种类比较少而且增多的概率很低的情况。

iOS SDK的应用

• Objective-C中的类簇就是简单工厂设计模式的一个应用。如果给NSNumber的工厂方法传入不同类型的数据，则会返回不同数据所对应的NSNumber的子类。

❤工厂方法模式

定义

工厂方法模式(Factory Method Pattern)又称为工厂模式，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，即通过不同的工厂子类来创建不同的产品对象。

适用场景

工厂方法模式的适用场景与简单工厂类似，都是创建数据和行为比较类似的对象。但是和简单工厂不同的是：在工厂方法模式中，因为创建对象的责任移交给了抽象工厂的子类，因此客户端需要知道其所需产品所对应的工厂子类，而不是简单工厂中的参数。

成员与类图

成员

工厂方法模式包含四个成员：

1. 抽象工厂（Abstract Factory）：抽象工厂负责声明具体工厂的创建产品的接口。
2. 具体工厂（Concrete Factory）：具体工厂负责创建产品。
3. 抽象产品（Abstract Product）：抽象产品是工厂所创建的所有产品对象的父类，负责声明所有产品实例所共有的公共接口。
4. 具体产品（Concrete Product）：具体产品是工厂所创建的所有产品对象类，它以自己的方式来实现其共同父类声明的接口。

模式类图

从类图中我们可以看到：抽象工厂负责定义具体工厂必须实现的接口，而创建产品对象的任务则交给具体工厂，由特定的子工厂来创建其对应的产品。

这使得工厂方法模式可以允许系统在不修改原有工厂的情况下引进新产品：只需要创建新产品类和其所对应的工厂类即可。

代码示例

场景概述

同样也是模拟上面的简单工厂例子中的场景（手机商店卖手机），但是由于这次是由工厂方法模式来实现的，因此在代码设计上会有变化。

与简单工厂模式不同的是：简单工厂模式里面只有一个工厂，而工厂方法模式里面有一个抽象工厂和继承于它的具体工厂。

因此同样的三个品牌的手机，我们可以通过三个不同的具体工厂：苹果手机工厂（IPhoneFactory），小米手机工厂 (MIPhoneFactory)，华为手机工厂（HWPhoneFactory）来生产。而这些具体工厂类都会继承于抽象手机工厂类：PhoneFactory，它来声明生产手机的接口。

代码实现

首先我们声明一个抽象工厂类 PhoneFactory：

//================== PhoneFactory.h ==================
#import "Phone.h"
@interface PhoneFactory : NSObject
+ (Phone *)createPhone;
@end
//================== PhoneFactory.m ==================
@implementation PhoneFactory
+ (Phone *)createPhone{
    //implemented by subclass
    return nil;
}
@end

抽象工厂类给具体工厂提供了生产手机的接口，因此不同的具体工厂可以按照自己的方式来生产手机。

下面看一下具体工厂：

//================== 苹果手机工厂IPhoneFactory ==================
@interface IPhoneFactory : PhoneFactory
@end
#import "IPhone.h"
@implementation IPhoneFactory
+ (Phone *)createPhone{
    IPhone *iphone = [[IPhone alloc] init];
    NSLog(@"iPhone has been created");
    return iphone;
}
@end
//================== 小米手机工厂 MIPhoneFactory ==================
@interface MPhoneFactory : PhoneFactory
@end
#import "MiPhone.h"
@implementation MPhoneFactory
+ (Phone *)createPhone{
    MiPhone *miPhone = [[MiPhone alloc] init];
    NSLog(@"MIPhone has been created");
    return miPhone;
}
@end
//================== 华为手机工厂 HWPhoneFactory ==================
@interface HWPhoneFactory : PhoneFactory
@end
#import "HWPhone.h"
@implementation HWPhoneFactory
+ (Phone *)createPhone{
    HWPhone *hwPhone = [[HWPhone alloc] init];
    NSLog(@"HWPhone has been created");
    return hwPhone;
}
@end

以上就是声明的抽象工厂类和具体工厂类。因为生产手机的责任分配给了各个具体工厂类，因此客户端只需要委托所需手机所对应的工厂就可以获得其生产的手机了。

下面我们用代码模拟一下该场景：

//================== Using by client ==================
//A phone store
Store *phoneStore = [[Store alloc] init];
//phoneStore wants to sell iphone
Phone *iphone = [IPhoneFactory  createPhone];
[iphone packaging];
[phoneStore sellPhone:iphone];
//phoneStore wants to sell MIPhone
Phone *miPhone = [MPhoneFactory createPhone];
[miPhone packaging];
[phoneStore sellPhone:miPhone];
//phoneStore wants to sell HWPhone
Phone *hwPhone = [HWPhoneFactory createPhone];
[hwPhone packaging];
[phoneStore sellPhone:hwPhone];

由上面的代码可以看出：客户端phoneStore只需委托iPhone，MIPhone，HWPhone对应的工厂即可获得对应的手机了。

而且以后如果增加其他牌子的手机，例如魅族手机，就可以声明一个魅族手机类和魅族手机的工厂类并实现createPhone这个方法即可，而不需要改动原有已经声明好的各个手机类和具体工厂类。

下面我们看一下该例子对应的 UML类图，可以更直观地看一下各个成员之间的关系：

代码对应的类图

优点

• 用户只需要关心其所需产品对应的具体工厂是哪一个即可，不需要关心产品的创建细节，也不需要知道具体产品类的类名。
• 当系统中加入新产品时，不需要修改抽象工厂和抽象产品提供的接口，也无须修改客户端和其他的具体工厂和具体产品，而只要添加一个具体工厂和与其对应的具体产品就可以了，符合了开闭原则（这一点与简单工厂模式不同）。

缺点

• 当系统中加入新产品时，除了需要提供新的产品类之外，还要提供与其对应的具体工厂类。因此系统中类的个数将成对增加，增加了系统的复杂度。

iOS SDK中的应用

• 暂未发现iOS SDK中使用工厂方法的例子，有知道的小伙伴欢迎留言。

抽象工厂模式

定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

适用场景

有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。比如系统中有多于一个的产品族，而每次只使用其中某一产品族，属于同一个产品族的产品将在一起使用。

在这里说一下产品族和产品等级结构的概念：

• 产品族：同一工厂生产的不同产品
• 产品等级结构：同一类型产品的不同实现

用一张图来帮助理解:

在上图中：

• 纵向的，不同形状，相同色系的图形属于同一产品组的产品，而同一产品族的产品对应的是同一个工厂。
• 横向的，同一形状，不同色系的图形属于统一产品等级结构的产品，而统一产品等级结构的产品对应的是同一个工厂方法。

下面再举一个例子帮助大家理解：

我们将小米，华为，苹果公司比作抽象工厂方法里的工厂：这三个工厂都有自己生产的手机，平板和电脑。
那么小米手机，小米平板，小米电脑就属于小米这个工厂的产品族；同样适用于华为工厂和苹果工厂。
而小米手机，华为手机，苹果手机则属于同一产品等级结构：手机的产品等级结构；平板和电脑也是如此。

结合这个例子对上面的图做一个修改可以更形象地理解抽象工厂方法的设计：

成员与类图

成员

抽象工厂模式的成员和工厂方法模式的成员是一样的，只不过抽象工厂方法里的工厂是面向产品族的。

1. 抽象工厂（Abstract Factory）：抽象工厂负责声明具体工厂的创建产品族内的所有产品的接口。
2. 具体工厂（Concrete Factory）：具体工厂负责创建产品族内的产品。
3. 抽象产品（Abstract Product）：抽象产品是工厂所创建的所有产品对象的父类，负责声明所有产品实例所共有的公共接口。
4. 具体产品（Concrete Product）：具体产品是工厂所创建的所有产品对象类，它以自己的方式来实现其共同父类声明的接口。

模式类图

• 抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构
• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

代码示例

场景概述

由于抽象工厂方法里的工厂是面向产品族的，所以为了贴合抽象工厂方法的特点，我们将上面的场景做一下调整：在上面两个例子中，商店只卖手机。在这个例子中我们让商店也卖电脑：分别是苹果电脑，小米电脑，华为电脑。

场景分析

如果我们还是套用上面介绍过的工厂方法模式来实现该场景的话，则需要创建三个电脑产品对应的工厂：苹果电脑工厂，小米电脑工厂，华为电脑工厂。这就导致类的个数直线上升，以后如果还增加其他的产品，还需要添加其对应的工厂类，这显然是不够优雅的。

仔细看一下这六个产品的特点，我们可以把这它们划分在三个产品族里面：

1. 苹果产品族：苹果手机，苹果电脑
2. 小米产品族：小米手机，小米电脑
3. 华为产品族：华为手机，华为电脑

而抽象方法恰恰是面向产品族设计的，因此该场景适合使用的是抽象工厂方法。下面结合代码来看一下该如何设计。

代码实现

首先引入电脑的基类和各个品牌的电脑类：

电脑基类：

//================== Computer.h ==================
@interface Computer : NSObject
//package to store
- (void)packaging;
@end
//================== Computer.m ==================
@implementation Computer
- (void)packaging{
    //implemented by subclass
}
@end

电脑品牌具体类：

//================== 苹果电脑类 MacBookComputer ==================
@interface MacBookComputer : Computer
@end
@implementation MacBookComputer
- (void)packaging{
     NSLog(@"MacBookComputer has been packaged");
}
@end
//================== 小米电脑类 MIComputer ==================
@interface MIComputer : Computer
@end
@implementation MIComputer
- (void)packaging{
    NSLog(@"MIComputer has been packaged");
}
@end
//================== 华为电脑类 MateBookComputer ==================
@interface MateBookComputer : Computer
@end
@implementation MateBookComputer
- (void)packaging{
    NSLog(@"MateBookComputer has been packaged");
}
@end

引入电脑相关产品类以后，我们需要重新设计工厂类。因为抽象工厂方法模式的工厂是面向产品族的，所以抽象工厂方法模式里的工厂所创建的是同一产品族的产品。下面我们看一下抽象工厂方法模式的工厂该如何设计：

首先创建所有工厂都需要集成的抽象工厂，它声明了生产同一产品族的所有产品的接口：

//================== Factory.h ==================
#import "Phone.h"
#import "Computer.h"
@interface Factory : NSObject
+ (Phone *)createPhone;
+ (Computer *)createComputer;
@end
//================== Factory.m ==================
@implementation Factory
+ (Phone *)createPhone{
    //implemented by subclass
    return nil;
}
+ (Computer *)createComputer{
    //implemented by subclass
    return nil;
}
@end

接着，根据不同的产品族，我们创建不同的具体工厂：

//================== 苹果产品族工厂 AppleFactory ==================
@interface AppleFactory : Factory
@end
#import "IPhone.h"
#import "MacBookComputer.h"
@implementation AppleFactory
+ (Phone *)createPhone{
    IPhone *iPhone = [[IPhone alloc] init];
    NSLog(@"iPhone has been created");
    return iPhone;
}
+ (Computer *)createComputer{
    MacBookComputer *macbook = [[MacBookComputer alloc] init];
    NSLog(@"Macbook has been created");
    return macbook;
}
@end
//================== 小米产品族工厂 MIFactory ==================
@interface MIFactory : Factory
@end
#import "MIPhone.h"
#import "MIComputer.h"
@implementation MIFactory
+ (Phone *)createPhone{
    MIPhone *miPhone = [[MIPhone alloc] init];
    NSLog(@"MIPhone has been created");
    return miPhone;
}
+ (Computer *)createComputer{
    MIComputer *miComputer = [[MIComputer alloc] init];
    NSLog(@"MIComputer has been created");
    return miComputer;
}
@end
//================== 华为产品族工厂 HWFactory ==================
@interface HWFactory : Factory
@end
#import "HWPhone.h"
#import "MateBookComputer.h"
@implementation HWFactory
+ (Phone *)createPhone{
    HWPhone *hwPhone = [[HWPhone alloc] init];
    NSLog(@"HWPhone has been created");
    return hwPhone;
}
+ (Computer *)createComputer{
    MateBookComputer *hwComputer = [[MateBookComputer alloc] init];
    NSLog(@"HWComputer has been created");
    return hwComputer;
}
@end

以上就是工厂类的设计。这样设计好之后，客户端如果需要哪一产品族的某个产品的话，只需要找到对应产品族工厂后，调用生产该产品的接口即可。假如需要苹果电脑，只需要委托苹果工厂来制造苹果电脑即可；如果需要小米手机，只需要委托小米工厂制造小米手机即可。

下面用代码来模拟一下这个场景：

//================== Using by client ==================
Store *store = [[Store alloc] init];
//Store wants to sell MacBook
Computer *macBook = [AppleFactory createComputer];
[macBook packaging];
[store sellComputer:macBook];
//Store wants to sell MIPhone
Phone *miPhone = [MIFactory createPhone];
[miPhone packaging];
[store sellPhone:miPhone];
//Store wants to sell MateBook
Computer *mateBook = [HWFactory createComputer];
[mateBook packaging];
[store sellComputer:mateBook];

上面的代码就是模拟了商店售卖苹果电脑，小米手机，华为电脑的场景。而今后如果该商店引入了新品牌的产品，比如联想手机，联想电脑，那么我们只需要新增联想手机类，联想电脑类，联想工厂类即可。

代码对应的类图

由于三个工厂的产品总数过多，因此在这里只体现了苹果工厂和小米工厂的产品。

优点

• 具体产品在应用层代码隔离，不需要关心产品细节。只需要知道自己需要的产品是属于哪个工厂的即可
• 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。

缺点

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
• 新增产品等级比较困难
• 产品等级固定，而产品族不固定，扩展性强的场景。

工厂总结

工厂的作用

• 封装变化:创建逻辑有可能变化，封装成工厂类之后，创建逻辑的变更对调用者透明。

• 代码复用:创建代码抽离到独立的工厂类之后可以复用。

• 隔离复杂性:封装复杂的创建逻辑，调用者无需了解如何创建对象。

• 控制复杂度:将创建代码抽离出来，让原本的函数或类职责更单一，代码更简洁。

工厂的复杂度

大体上看，简单工厂模式，工厂方法模式和抽象工厂模式的复杂程度是逐渐升高的。

• 简单工厂模式使用不同的入参来让同一个工厂生产出不同的产品。
• 工厂方法模式和抽象工厂模式都需要有特定的工厂类来生产对应的产品；而工厂方法模式里的工厂是面向同一产品等级的产品；而抽象工厂方法模式里的工厂是面向同一产品族的产品的。

在实际开发过程中，我们需要根据业务场景的复杂程度的不同来采用最适合的工厂模式。

参考

面向对象设计的设计模式（一）：创建型模式（附 Demo & UML类图）