iOS开发-工厂模式

工厂模式算是开发中比较常见的设计模式，简单工厂模式，工厂模式和抽象工厂模式，都属于工厂模式。简单工厂模式（simple factory）是类的建立模式，静态工厂方法（static factory method）模式，简单工厂模式就是由一个工厂类根据传入的参数决定建立哪种的产品类。简单工厂模式会包含过多的判断条件，维护起来不是特别方便，工厂模式是主要经过依赖倒置将类的实例化推迟到子类中，实现动态扩展。抽象工厂模式是一个对象产品家族，根据需求提供不一样的对象。

简单工厂模式

以前的文章中写过一篇简单工厂模式，假设咱们我有一个服装加工工厂，能够根据不一样的需求生产不一样的服饰，定义一个服装基类和工厂类：

@protocol DressProtocol <NSObject>

@optional
-(void)provideMaterial;

@optional
-(void)product;

@end

@interface Dress : NSObject<DressProtocol>

@end

 服装Dress子类ForeignDress:

@implementation ForeignDress


-(void)provideMaterial{
    NSLog(@"ForeignDress--准备原材料");
}

-(void)product{
    NSLog(@"ForeignDress--生产");
}

@end

 ChinaDress子类：

@implementation ChinaDress

-(void)provideMaterial{
    NSLog(@"ChinaDress---准备原材料");
}

-(void)product{
    NSLog(@"ChinaDress---生产");
}

@end

工厂类Manufactor：

@protocol ManufactorProtocol <NSObject>

@optional
-(Dress *)createDress:(NSString *)type;

@end

@interface Manufactor : NSObject<ManufactorProtocol>

-(void)start:(NSString *)type;

-(void)simpleStart:(NSString *)type;

-(void)startByCondition:(NSString *)type;

@end

方法实现:

-(void)start:(NSString *)type{
    if ([type isEqualToString:@"Foreign"]) {
        dress=[[ForeignDress alloc]init];
    }else if([type isEqualToString:@"China"]){
        dress=[[ChinaDress alloc]init];
    }
    [dress provideMaterial];
    [dress product];
}
//博客园-FlyElephant 简单工厂
-(void)simpleStart:(NSString *)type{
    dress=[ManuFactory dressInstance:type];
    [dress provideMaterial];
    [dress product];
}

方法调用:

    Manufactor  *factor=[[Manufactor alloc]init];
    [factor start:@"Foreign"];
    [factor simpleStart:@"China"];
    NSLog(@"博客园-FlyElephant");
    NSLog(@"http://www.cnblogs.com/xiaofeixiang/");

测试效果:

第一种咱们在工厂中直接经过type类型判断，不一样的类型生产不一样的服装，可是若是type类型过多并且type实现的不必定的Dress服装类，因此放在Manufactor不合适，咱们将其实现单独放在一个简单工厂里面。 你会发现，每次不一样的类型咱们都要去修改简单工厂，牵一发而动，不符合设计模式的"对扩展开放，对修改关闭"的原则，工厂模式能够解决简单工厂没法解决的问题。

工厂模式

假设公司效益比较好，工厂须要新增北京分厂，上海分厂的时候，这是时候经过简单工厂没法解决类扩展的问题，简单工厂之因此简单就是在于在同一个地方进行对象处理，工厂方法模式（Factory Method Pattern）工在基类中创建一个抽象方法，子类能够经过改写这一方法来改变建立对象的具体过程。工厂方法模式让子类来决定如何建立对象，来达到封装的目的。

 假设咱们新增了北京分厂,属于北京分厂的服装能够直接调用北京工厂来完成:

@implementation BJManufactor

-(Dress *)createDress:(NSString *)type{
    Dress *dress;
    if ([type isEqualToString:@"BJ"]) {
        dress=[[BJDress alloc]init];
    }else if([type isEqualToString:@"BJSpecial"]){
        dress=[[BJSpecialDress alloc]init];
    }
    return dress;
}

@end

Manufactor基类中的条件判断:

-(void)startByCondition:(NSString *)type{
    Dress *myDress=[self createDress:type];
    [myDress provideMaterial];
    [myDress product];
}

具体调用实现:

    Manufactor  *bjfactor=[[BJManufactor alloc]init];
    [bjfactor startByCondition:@"BJ"];
    NSLog(@"博客园-FlyElephant");
    NSLog(@"http://www.cnblogs.com/xiaofeixiang/");

效果:

从对象的建立来说，这个将对象的建立扩展到了对象子类，从设计原则中中的依赖角度来看，原来的工厂须要依赖的各类具体的服装子类的引用，如今将这些进行各类分类，这里是以工厂的形式进行分类，抽象组件不依赖于具体的实现组件，已经完成的扩展能够不须要变化，若是有新增需求只须要增长新的功能接口，高层组件不须要太大的变化。

抽象工厂模式

抽象工厂模式提供一个接口，用于建立一个对象家族，而无需指定具体类。 工厂方法只涉及到建立一个对象的状况，有时咱们须要一族对象，上面我针对的对象是工厂，当咱们须要工厂提供提供不一样的原料，须要的不一样的启动资金和人数，才能成立一个真正的工厂，将每一个工厂都聚合在一块儿造成统一的接口，这样咱们能够称之为

抽象工厂基类，这里只提供实现了Cloth:

@protocol AbstractFactory <NSObject>

@optional
-(Cloth *)provideCloth;

@end

@interface AbstractFactory : NSObject<AbstractFactory>

@end

抽象工厂子类BJAbstractFactory:

@implementation BJAbstractFactory

-(Cloth *)provideCloth{
    return [[Cloth alloc] init];
}

@end

Cloth类:

@implementation Cloth

-(void)clothMethod{
    NSLog(@"Cloth--Cloth");
}

@end

Manufactor类中添加两个新的方法:

-(void)configFactory:(AbstractFactory *)factory{
    abstractFactory=factory;
}

-(void)startWithFactory:(NSString *)type{
    Dress *myDress=[self createDress:type];
    cloth=[abstractFactory provideCloth];
    [cloth clothMethod];
    [myDress provideMaterial];
    [myDress product];
}

　方法调用:

    Manufactor  *factor=[[BJManufactor alloc]init];
    [factor configFactory:[[BJAbstractFactory alloc] init]];
    [factor startWithFactory:@"BJ"];
    NSLog(@"博客园-FlyElephant");
    NSLog(@"http://www.cnblogs.com/xiaofeixiang/");

　效果:

从实现逻辑来看抽象工厂模式和工厂模式和相似，抽象工厂模式的重点在于建立抽象接口来建立一组相关的产品。抽象工厂模式中，抽象工厂定义接口，全部的具体工厂必须实现该接口，该接口包含一组方法用来生产产品。每一个具体工厂可以生产一整组的产品。工程实践中根据实际状况进行择优选择~