场景
举个简单的例子，拿魔兽世界来说（作者没玩过，哪里说得不对请多多见谅，能明白意思就好）
里面的角色分成许多种族：人族、兽族
虽然种族不一样但是每个种族都会有一些相同的职业：战士、术士
然而因为种族不同，每个职业当中的一些加成也不一样。
假如一个角色的有如下间接属性：力量（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
@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
@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];
417D10AB-EA86-4E06-945C-BFDC189423F5.png
以上就是所谓的生成器设计模式了。
现在已有例子的情况下在倒过来看看生成器设计模式本身：
生成器包含两个主要的重要角色：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.构建过程需要以不同的方式构建对象。