建造者模式的解析-iOS

建造者模式的解析-iOS

其他设计模式的介绍

1、简单工厂模式、工厂模式、抽象工厂模式的解析-iOS
2、建造者模式的解析-iOS
3、单例模式的解析-iOS
4、原型模式的解析-iOS

概率描述

设计模式的一种，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。百度百科

实用场景

1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2 当构造过程必须允许被构造的对象有不同表示时。百度百科

角色

1 Builder：为创建一个产品对象的各个部件指定抽象接口。
2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。
3 Director：构造一个使用Builder接口的对象。
4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。百度百科

案例解析

就以我刚上大学的时候，为了省钱，去买了一台组装的电脑，我们以这个为例子。
我们去电脑城区组装电脑，老板一般会问我们需要拿来干什么，比如玩游戏还是学习，学习的是什么，对电脑有什么要求。他会根据我们描述来给我们挑选CPU，屏幕，主板、内存等等。再要组装电脑的工作人员去组装电脑(其实那个时候我是老板自己组装的，我们假设老板请了个工人组装电脑)。然后我们以我买组装电脑为例来解析每个角色。

Builder：就是我们具体的配件，比如CPU，主板、屏幕、内存等等，组成电脑的硬件。
ConcreteBuilder：就是老板请的根据提供的配件组装电脑的组装人员。
Director：就是我们的老板，分析我们需求，给我们挑选硬件设备。
Product：就是我们买的组装电脑。

我们去电脑店先找老板，老板根据我们的需求，告诉我们需要什么样配置达电脑
老板是Director，代码如下

//.h文件
#import <Foundation/Foundation.h>
#import "BuilderMemory.h"
#import "BuilderMainboard.h"
#import "BuilderCPU.h"
#import "BuilderScreen.h"
#import "ProductComputer.h"
#import "ConcreteBuilderPeople.h"

@interface DirectorPeople : NSObject
/*
 *分析需要的配件，告诉组装人员去组装电脑
 */
-(ProductComputer *)gainComPuter;
@end

//.m文件
#import "DirectorPeople.h"

@implementation DirectorPeople
-(ProductComputer *)gainComPuter{
    ConcreteBuilderPeople *concreteBuilderPeople = [[ConcreteBuilderPeople alloc]init];
    //根据老板的清单组装英特尔的CPU，华硕的主板，戴尔的屏幕，金士顿的内存的电脑
   return  [concreteBuilderPeople assembleComputer:IntelCPU andMainBoard:AsustekMainboard andScreen:DaleScreen andMemoryType:KingstonMemory];
}
@end

下面是每个具体的配件Builder
CPU的代码

//.h文件
#import <Foundation/Foundation.h>
typedef enum {
    IntelCPU,//英特尔
    CeleronCPU,//赛扬
    CoreCPU,//酷睿
}CPUType;
@interface BuilderCPU : NSObject
@property (nonatomic,copy)NSString *CPU;
-(void)createCPU:(CPUType)cpuType;
@end

//.m文件
#import "BuilderCPU.h"

@implementation BuilderCPU
-(void)createCPU:(CPUType)cpuType{
    switch (cpuType) {
        case IntelCPU:
            NSLog(@"英特尔CPU");
            self.CPU =@"英特尔CPU";
            break;
        case CeleronCPU:
            NSLog(@"赛扬CPU");
            self.CPU =@"赛扬CPU";
            break;
        case CoreCPU:
            NSLog(@"酷睿CPU");
            self.CPU =@"酷睿CPU";
            break;

        default:
            break;
    }
}
@end

主板的代码

//.h文件
#import <Foundation/Foundation.h>
typedef enum {
    AsustekMainboard,//华硕
    MSIMainboard,//微星
    GIGABYTEMainboard,//技嘉
}MainboardType;

@interface BuilderMainboard : NSObject
@property(nonatomic,copy)NSString *mainboard;
-(void)createMainboard:(MainboardType)mainboardType;

@end


//.m文件

#import "BuilderMainboard.h"

@implementation BuilderMainboard
-(void)createMainboard:(MainboardType)mainboardType{
    switch (mainboardType) {
        case AsustekMainboard:
            NSLog(@"华硕主板");
            self.mainboard =@"华硕主板";
            break;
        case MSIMainboard:
            NSLog(@"微星主板");
            self.mainboard =@"微星主板";
            break;
        case GIGABYTEMainboard:
            NSLog(@"技嘉主板");
            self.mainboard =@"技嘉主板";
            break;

        default:
            break;
    }
}
@end

屏幕的代码

//.h文件
#import <Foundation/Foundation.h>
typedef enum {
    DaleScreen,//戴尔
    AsustekScreen,//华硕
    AOCScreen,//AOC
}ScreenType;

@interface BuilderScreen : NSObject
@property(nonatomic,copy)NSString *screen;
-(void)createScreen:(ScreenType)screenType;
@end

//.m文件
#import "BuilderScreen.h"

@implementation BuilderScreen
-(void)createScreen:(ScreenType)screenType{
    switch (screenType) {
        case DaleScreen:
            NSLog(@"戴尔屏幕");
            self.screen =@"戴尔屏幕";
            break;
        case AsustekScreen:
            NSLog(@"华硕屏幕");
            self.screen =@"华硕屏幕";
            break;
        case AOCScreen:
            NSLog(@"AOC屏幕");
            self.screen =@"AOC屏幕";
            break;

        default:
            break;
    }
}
@end

内存的代码

//.h文件
#import <Foundation/Foundation.h>
typedef enum {
    KingstonMemory,//金士顿
    CrucialMemory,//英睿达
    GALAXYMemory,//影驰
}MemoryType;

@interface BuilderMemory : NSObject

@property(nonatomic,copy)NSString *memory;
-(void)createMemory:(MemoryType)memoryType;
@end

//.m文件
#import "BuilderMemory.h"

@implementation BuilderMemory
-(void)createMemory:(MemoryType)memoryType{
    switch (memoryType) {
        case KingstonMemory:
            NSLog(@"金士顿内存");
            self.memory = @"金士顿内存";
            break;
        case CrucialMemory:
            NSLog(@"英睿达内存");
            self.memory = @"英睿达内存";
            break;
        case GALAXYMemory:
            NSLog(@"影驰内存");
            self.memory = @"影驰内存";
            break;

        default:
            break;
    }
}
@end

然后就是我的产品类Product—电脑
我们的电脑有CPU，主板、屏幕、内存等这几个属性，其他的一些属性，我没有列出了，只是以这些为列子。

//.h文件
#import <Foundation/Foundation.h>

@interface ProductComputer : NSObject
@property (nonatomic,copy)NSString *CPU;
@property(nonatomic,copy)NSString *mainboard;
@property(nonatomic,copy)NSString *screen;
@property(nonatomic,copy)NSString *memory;

@end


//.m文件
#import "ProductComputer.h"

@implementation ProductComputer
- (NSString *)description{
   return  [NSString stringWithFormat:@"我组装的电脑是%@，%@，%@，%@",self.CPU,self.mainboard,self.screen,self.memory];
}
@end

然后老板吩咐我们的组装人员去组装电脑 — ConcreteBuilder
组装人员的代码

//.h文件
#import <Foundation/Foundation.h>
#import "BuilderMemory.h"
#import "BuilderMainboard.h"
#import "BuilderCPU.h"
#import "BuilderScreen.h"
#import "ProductComputer.h"

@interface ConcreteBuilderPeople : NSObject
/*   组装电脑
 *  cpuType --- CPU的类型
 *  mainBoard --- 主板，类型
 *  screenType --- 屏幕类型
 *  memoryType --- 内存类型
 */
-(ProductComputer *)assembleComputer:(CPUType)cpuType andMainBoard:(MainboardType)mainBoard andScreen:(ScreenType)screenType andMemoryType:(MemoryType)memoryType;

@end

//.m文件
#import "ConcreteBuilderPeople.h"

@implementation ConcreteBuilderPeople
-(ProductComputer *)assembleComputer:(CPUType)cpuType andMainBoard:(MainboardType)mainBoard andScreen:(ScreenType)screenType andMemoryType:(MemoryType)memoryType{
    //获取CPU
    BuilderCPU *builderCPU = [[BuilderCPU alloc] init];
    [builderCPU createCPU:cpuType];

    //获取主板
    BuilderMainboard *builderMainboard = [[BuilderMainboard alloc]init];
    [builderMainboard createMainboard:mainBoard];

    //获取内存
    BuilderMemory *builderMemory = [[BuilderMemory alloc]init];
    [builderMemory createMemory:memoryType];


    //获取屏幕
    BuilderScreen *builderScreen = [[BuilderScreen alloc]init];
    [builderScreen createScreen:screenType];

    //组装电脑
    ProductComputer *productComputer = [[ProductComputer alloc]init];
    productComputer.CPU = builderCPU.CPU;
    productComputer.mainboard = builderMainboard.mainboard;
    productComputer.memory = builderMemory.memory;
    productComputer.screen = builderScreen.screen;
    return productComputer;

}

@end

最后就是电脑组装好了，我来取电脑

    //建造者模式
    //购买组装电脑
    DirectorPeople *directorPeople = [[DirectorPeople alloc]init];
    ProductComputer *productComputer = [directorPeople gainComPuter];

优缺点

优点
1符合依赖倒转原则：可以商品和商品创建的过程分开，使用一样的创建方式，根据客户的不同需求创建出不同的商品，就相当于细节依赖抽象，就是说我们的具体商品，依赖于不同具体的构成部件。
2、符合开发-封闭原则：易于扩展，新增加新的商品，只要修改我们的部件的类型、大小，可以根据不同的建造者建造出不同的商品。
缺点
这种模式只能使用于有很多共同点的商品，如果一个是汽车，和电脑，他们的共同点很少，不太适用于建造者模式

总结

如果有写的不正确或者侵权的，希望大家给我提出来，我会及时修改。谢谢大家。