建造者模式(Builder)

在实践中，主要用到较早者模式的情况为：

1. 创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。
2. 要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

本例拿机器人制造来演示建造模式的，假设机器人的制造过程是：造头、造身体、造手、造脚，如此我们可以抽象出机器人的四个制造方法，其制造顺序姑且认为是头、身体、手脚，基于这样的场景，我们可以使用建造者模式来创建不同的机器人了。本例的具体的需要制造的机器人为超人机器人和蝙蝠侠机器人，因此关于建造者的类可以这样设计了。其中抽象建造者的类的定义如下：

#import <Foundation/Foundation.h>

// 抽象建造者
@interface Roboter : NSObject
{
    @protected
    NSString* _header;
    NSString* _body;
    NSString* _hand;
    NSString* _feet;
}
@property (nonatomic, readonly) NSString* header;
@property (nonatomic, readonly) NSString* body;
@property (nonatomic, readonly) NSString* hand;
@property (nonatomic, readonly) NSString* feet;

// 抽象出来的建造方法
- (void) makeHeader;
- (void) makeBody;
- (void) makeHand;
- (void) makeFeet;
- (Roboter*) getRoboter;

@end

由于是抽象出来的类，其实现部分可以为空的，但是本例将实现部分当做默认的使用，其实现如下所示：

#import "Roboter.h"

// 抽象建造者实现的默认方法
@implementation Roboter
- (void) makeHeader
{
    _header = @"header";
}
- (void) makeBody
{
    _body = @"body";
}
- (void) makeHand
{
    _hand = @"hand";
}
- (void) makeFeet
{
    _feet = @"feet";
}
- (Roboter*) getRoboter
{
    return self;
}
@end

而两个具体建造者需要继承抽象的建造类，然后重载抽象出来的制造方法，其实现分别为：

// 具体建造者-超人机器人生产商
// 重载建造方法
@implementation SuperManRoboter
- (void) makeHeader
{
    _header = @"super man header";
}
- (void) makeBody
{
    _body = @"super man body";
}
- (void) makeHand
{
    _hand = @"super man hand";
}
- (void) makeFeet
{
    _feet = @"super man feet";
}
@end

// 具体建造者-蝙蝠侠机器人生产商
// 重载建造方法
@implementation BatMenRoboter
- (void) makeHeader
{
    _header = @"bat man header";
}
- (void) makeBody
{
    _body = @"bat man body";
}
- (void) makeHand
{
    _hand = @"bat man hand";
}
- (void) makeFeet
{
    _feet = @"bat man feet";
}
@end

两个建造者都在自己的实现中实现机器人各部分的制造，然后就是需要创建指导者（Director）了，该类了解抽象出的制造者类，其唯一的方法就是下命令要求创建者开始制造，然后调用抽象出来的制造方法，其实现如下所示：

@implementation RobotMaker
- (void) make:(Roboter*)roboter
{
    // director-指导者
    // 生产机器人的固定流程
    [roboter makeHeader];
    [roboter makeBody ];
    [roboter makeHand];
    [roboter makeFeet];
}
@end

如此，客户端通过指定建造的机器人类型，即可使用建造者模式创建所需要的机器人，其客户端的调用代码大致如下所示：

@implementation Child
- (void) wantRoboterNamed:(NSString*)name
{
    // client-客户端
    RobotMaker* maker = [[RobotMaker alloc] init];
    Roboter* roboter = nil;
    if ([name isEqualToString:@"BatMan"])
    {
        roboter = [[BatMenRoboter alloc] init];
    }
    else if([name isEqualToString:@"SuperMan"])
    {
        roboter = [[SuperManRoboter alloc] init];
    }
    // 制造机器人
    [maker make:roboter];
    
    NSLog(@"Robboter Info : \n"
          "header -> %@\n"
          "body   -> %@\n"
          "hand   -> %@\n"
          "feet   -> %@\n",
          roboter.header, roboter.body, roboter.hand, roboter.feet);
    
    // 可使用获取方法取得建造的产品
    // [roboter getRoboter];
}
@end

客户端创建了指导者和具体建造者，然后通过指导者下命令开始创建对象，最后通过抽象方法getResult获取创建的对象。

通过上述的学习，我们可以发现，其实产品一开始就由客户端创建了，但是此时的产品不能称之为真正的产品，我们还得给该产品一步步的组装加工，而加工部分被分离到建造者具体的类里面实现，这样实现产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象，大大降低复杂对象的创建容易度。使用建造者模式的好处有：

• 使用建造者模式可以使客户端不必知道产品内部组成的细节。
• 具体的建造者类之间是相互独立的，对系统的扩展非常有利。
• 由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。