场景
举个简单的例子，拿魔兽世界来说（作者没玩过，哪里说得不对请多多见谅，能明白意思就好）
里面的角色分成许多种族：人族、兽族
虽然种族不一样但是每个种族都会有一些相同的职业：战士、术士
然而因为种族不同，每个职业当中的一些加成也不一样。
假如一个角色的有如下间接属性：力量（strength）、耐力（Stamina）、智力（Intelligence）、敏捷（Agility）。
直接属性就两个：攻击力（Aggressiveness）、防御力（Protection）
我们认为：
力量越高 攻击 和 防御 越高。
耐力越高 攻击欲望就下降了，所以攻击下降， 防御变高。
智力越高越懂得命中要害，但是会让自己更加危险，所以攻击变高，防御下降。
敏捷越高越会躲避敌人攻击，但是攻击的时机变少给了，所以攻击下降，防御变高
由于种族和职业导致每种间接属性对直接属性的加成有所不同，列表如下：
- 种族 影响着初始值
人族：对于力量和耐力加成不高，智力和敏捷加成很高
| 属性 | |
|---|---|
| 力量（Strength） | 20 |
| 耐力（Stamina） | 20 |
| 智力（Intelligence） | 30 |
| 敏捷（Agility） | 30 |
兽族：力量和耐力加成高，智力和敏捷加成低
| 属性 | |
|---|---|
| 力量（Strength） | 30 |
| 耐力（Stamina） | 30 |
| 智力（Intelligence） | 20 |
| 敏捷（Agility） | 20 |
- 职业 影响着副属性对主属性的加成
战士：力量、耐力 和 敏捷的攻击加成增高
| 防御 | 攻击 | |
|---|---|---|
| 力量（Strength） | +2 | +2 |
| 耐力（Stamina） | +2 | -1 |
| 智力（Intelligence） | - 2 | +2 |
| 敏捷（Agility） | +1 | -1 |
术士：智力增加攻击力和防御力
| 防御 | 攻击 | |
|---|---|---|
| 力量（Strength） | +1 | +1 |
| 耐力（Stamina） | +2 | -1 |
| 智力（Intelligence） | + 5 | +5 |
| 敏捷（Agility） | +2 | -1 |
从上面的表格我们举一个例子：
兽人战士每增加一点力量，会增加3点防御 和 2点攻击
人族法师每增加一点智力，会增加3点防御 和 5点攻击 （尼玛 我要是策划我估计我能被打死）
1.你根本就不知道用户会创建什么种族 什么职业，所以只能动态加载。
2.这里只有4种情况，但实际当中可能有十几个职业和属各种族，所以根本没办法一一举例出来，而且每增加一个种族这个枚举就会成倍的增加。
的·这里生成器模式就用上了。
我们这里先从代码开始讲，然后再开始分析生成器模式。
实践
首先我们建一个Character类，代表角色。
角色很简单，仅仅有防御力、攻击力、流量、耐力、智力、敏捷这6个属性
@interface Character : NSObject
// 攻击力
@property (nonatomic, assign) NSInteger protection;
// 防御力
@property (nonatomic, assign) NSInteger power;
// 力量
@property (nonatomic, assign) NSInteger strength;
// 耐力
@property (nonatomic, assign) NSInteger stamina;
// 智力
@property (nonatomic, assign) NSInteger intelligence;
// 敏捷
@property (nonatomic, assign) NSInteger agility;
@end
charater本身仅仅只是一个Model，它本身并不能按照咱们需要的规则来变动自身的数值。这时候我们需要一个builder来按照我们之前定好的规则来生产它。在这里我们所说的builder就是职业(Profession)，因为不同的职业所产生的character的数值变化规则是不一样的。
这个类需要有以下功能：
1.创建一个新职业
2.返回最后所生成好的Character
3.设定属性的初始值
.h
#import <Foundation/Foundation.h>
@class Character;
@interface Profession : NSObject
/**
最后所生成的角色（Character）
*/
@property (nonatomic, strong, readonly) Character *character;
/**
初始化并且创建一个新的职业
*/
- (Profession *)buildNewCharacter;
@end
@interface Profession (Attribute)
- (Profession *)buildStrength:(NSInteger)strength;
- (Profession *)buildStamina:(NSInteger)stamina;
- (Profession *)buildIntelligence:(NSInteger)intelligence;
- (Profession *)buildAgility:(NSInteger)agility;
@end
.m
#import "Profession.h"
#import "Character.h"
@interface Profession ()
@property (nonatomic, strong) Character *character;
@end
@implementation Profession
- (Profession *)buildNewCharacter {
self.character = nil;
self.character = [[Character alloc] init];
return self;
}
- (Profession *)buildStrength:(NSInteger)strength {
self.character.strength = strength;
return self;
}
- (Profession *)buildStamina:(NSInteger)stamina {
self.character.stamina = stamina;
return self;
}
- (Profession *)buildIntelligence:(NSInteger)intelligence {
self.character.intelligence = intelligence;
return self;
}
- (Profession *)buildAgility:(NSInteger)agility {
self.character.agility = agility;
return self;
}
@end
.m的实现很简单就是简单的赋值，并且返回本身。
因为并不知道具体职业所以仅仅是赋值而已。
返回本身是为了链式编程，当然也可以直接去掉返回。
接下来我们根据不同的职业来子类化Profession。
.h
#import "Profession.h"
@interface Saber : Profession
@end
@interface Saber (Override)
- (Profession *)buildStrength:(NSInteger)strength;
- (Profession *)buildStamina:(NSInteger)stamina;
- (Profession *)buildIntelligence:(NSInteger)intelligence;
- (Profession *)buildAgility:(NSInteger)agility;
@end
.m
#import "Saber.h"
#import "Character.h"
@interface Saber ()
@end
@implementation Saber
- (Profession *)buildStrength:(NSInteger)strength {
[super buildStrength:strength];
self.character.power += strength * 2;
self.character.protection += strength * 2;
return self;
}
- (Profession *)buildStamina:(NSInteger)stamina {
[super buildStamina:stamina];
self.character.power += stamina * 2;
self.character.protection -= stamina * 1;
return self;
}
- (Profession *)buildIntelligence:(NSInteger)intelligence {
[super buildIntelligence:intelligence];
self.character.power -= intelligence * 2;
self.character.protection += intelligence * 2;
return self;
}
- (Profession *)buildAgility:(NSInteger)agility {
[super buildAgility:agility];
self.character.power += agility * 1;
self.character.protection -= agility * 1;
return self;
}
@end
如法炮制法师（Caster）职业
.h
#import "Profession.h"
@interface Caster : Profession
@end
@interface Caster (Override)
- (Profession *)buildStrength:(NSInteger)strength;
- (Profession *)buildStamina:(NSInteger)stamina;
- (Profession *)buildIntelligence:(NSInteger)intelligence;
- (Profession *)buildAgility:(NSInteger)agility;
@end
.m
#import "Caster.h"
#import "Character.h"
@interface Caster ()
@end
@implementation Caster
- (Profession *)buildStrength:(NSInteger)strength {
[super buildStrength:strength];
self.character.power += strength * 1;
self.character.protection += strength * 1;
return self;
}
- (Profession *)buildStamina:(NSInteger)stamina {
[super buildStamina:stamina];
self.character.power += stamina * 2;
self.character.protection -= stamina * 1;
return self;
}
- (Profession *)buildIntelligence:(NSInteger)intelligence {
[super buildIntelligence:intelligence];
self.character.power += intelligence * 5;
self.character.protection += intelligence * 5;
return self;
}
- (Profession *)buildAgility:(NSInteger)agility {
[super buildAgility:agility];
self.character.power += agility * 2;
self.character.protection -= agility * 1;
return self;
}
@end
然后再来看看我们的种族（Race），种族决定了初始值，然后不同的初始值由于不同的职业作用（无职业也是一种职业），产生不同的角色。我们最后的一部就是配置不同的种族来配置不同的初始值，然后引入不同的职业。
我们创建CharacterCreator来完成此工作。
.h
#import <Foundation/Foundation.h>
@class Character;
@class Profession;
@interface CharacterCreator : NSObject
/**
创建兽人角色
*/
- (Character *)createOrcPlayerWithProfession:(Profession *)profession;
/**
创建人类角色
*/
- (Character *)createHumanPlayerWithProfession:(Profession *)profession;
@end
.m
#import "CharacterCreator.h"
#import "Character.h"
#import "Profession.h"
@implementation CharacterCreator
/**
创建兽人角色
*/
- (Character *)createOrcPlayerWithProfession:(Profession *)profession {
return [[[[[profession buildNewCharacter]
buildStrength:30]
buildStamina:30]
buildIntelligence:20]
buildAgility:20].character;
}
/**
创建人类角色
*/
- (Character *)createHumanPlayerWithProfession:(Profession *)profession {
return [[[[[profession buildNewCharacter]
buildStrength:20]
buildStamina:20]
buildIntelligence:30]
buildAgility:30].character;
}
@end
OK代码到此就完事了，来看看使用：
Saber *saber = [[Saber alloc] init];
Caster *caster = [[Caster alloc] init];
CharacterCreator *creator = [[CharacterCreator alloc] init];
Character *orcSaber = [creator createOrcPlayerWithProfession:saber];
Character *orcCaster = [creator createOrcPlayerWithProfession:caster];
Character *humanSaber = [creator createHumanPlayerWithProfession:saber];
Character *humanCaster = [creator createHumanPlayerWithProfession:caster];
以上就是所谓的生成器设计模式了。
现在已有例子的情况下在倒过来看看生成器设计模式本身：
生成器包含两个主要的重要角色：Director（CharacterCreator） 和 Builder（Profession）。
Director知道Builder应该建造什么，一参数向其提供缺少的信息来建造特定产品（Character）。
Builder知道究竟如何在缺少某些特定信息的情况下建造什么。
Builder是一个抽象接口（需要子类化），他有一个buildPart方法，该方法由其子类实现，来构造实际的产品（- (Profession *)buildStrength:(NSInteger)strength;）。实体类则有一个getResult方法，向客户端返回构造完毕的Product（@property (nonatomic, strong, readonly) Character *character;）。
Director定义了一个construct方法，命令Builder的实例去buildPart。（- (Character *)createOrcPlayerWithProfession:(Profession *)profession;）
Director和Builder形成一种聚合关系。这一位置Builder是一个组成部分，与Director结合，一是整个模式运转，但同时，Director并不负责Builder的生存期。
何时使用
1.需要创建涉及各种部件的复杂对象，创建对象的算法应该独立于不见得装配方式。
2.构建过程需要以不同的方式构建对象。
再举一个生动点的例子：
大家把Director 想象成 UI。把Builder想象成程序员。
每个程序员都会以自己不同的方式来创建UI。不同的程序员创建的同一个UI肯定有区别。
程序员会创建UI但是不知道具体应该做成什么样子。
UI知道应该做成什么样子，但是不知道如何实现。
所以UI给程序员原型图，程序员开始制作。
