关于iOS工厂模式的理解

IOS中存在非常多的类工厂模式的设计方式;
丰富了类的实现模式, 父类可以声明多种初始化方法提供给子类,子类按照自身需求可以动态的调用父类的方法完成
特定的初始化操作;
例如uiview的实现
initwithframe
init

一个从严格意义上讲的工厂模式应该是一个纯虚的构造方法.父类并不进行初始化,而是有子类进行具体对象的创建
父类的初始化方法可以理解为工厂;
开放不同接口携带不同参数的初始化方法可以理解为父类所提供的多个工厂;
子类可以通过其特定的工厂,生产出特定的对象

实际上很多程序员在开发的时候并没有工厂模式的这种概念,但是实际上他们在实现程序功能的时候往往会用到工厂
方法的开发思想; 从我的角度出发,我认为工厂方法是一种规范化的编程习惯和规范,也是众多前辈在开发过程中积累的
经验,可以提升开发效率和可维护性

IOS的Foundation框架中,中我们常用到一些类头在初始化方法或者调用系统方法的时候用到,也有些人管这个叫做类簇
比如说 NSArray NSString NSDictionary ,我们通过他们创建的对象都是其子类的实例化,并非其本身的实例化

设计优势的体现:
一个工厂满足所有要求, 不需要创建过多相似的类简化了编程,方便程序员开发;因为很多类名不用记了,这也是面向对象
编程的集中体现

通过上面的分析，我们大致可以总结出工厂这种设计模式的应用场景：

（1）当一个类并不知道要创建的具体对象是什么，交由子类处理

（2）当一些类有相似的行为和结构，只是具体实现不同时，可以抽象出工厂

（3）使用者并不在乎具体类型，只在乎接口约定的行为，并且这种行为有个体差异

首先，我们创建一个抽象的工程类，在其中创建一些私有的子类：

#import <Foundation/Foundation.h>
//交通工具的枚举
typedef enum {
car,
boat,
airport,
bycicle,
bus,
taxi
}ToolsName;
//代理
 
@protocol TransPortationDelegate <NSObject>
 
-(void)toHome:(Class)class;
 
@end
//抽象工厂类
 
@interface TramsPortationFactory : NSObject
+(TramsPortationFactory*)buyTool:(ToolsName)tool;
//共有的方法接口
 
-(int)shouldPayMoney;
-(void)run;
@property(nonatomic,strong)id<TransPortationDelegate>delegate;
@end
//具体实现的子类
@interface CarFactory : TramsPortationFactory
 
@end
@interface BoatFactory : TramsPortationFactory
 
@end
@interface AirportFactory : TramsPortationFactory
 
@end
@interface BycicleFactory : TramsPortationFactory
 
@end
@interface TaxiFactory : TramsPortationFactory
 
@end
@interface BusFactory : TramsPortationFactory
 
@end

实现文件如下：

#import "TramsPortationFactory.h"
 
@implementation TramsPortationFactory
//实现的创建方法
+(TramsPortationFactory*)buyTool:(ToolsName)tool{
    switch (tool) {
        case car:
            return [[CarFactory alloc]init];
            break;
        case airport:
            return [[AirportFactory alloc]init];
            break;
        case bycicle:
            return [[BycicleFactory alloc]init];
            break;
        case boat:
            return [[BoatFactory alloc]init];
            break;
        case taxi:
            return [[TaxiFactory alloc]init];
            break;
        case bus:
            return [[BusFactory alloc]init];
            break;
        default:
            break;
    }
}
 
-(int)shouldPayMoney{
    return 0;
}
-(void)run{
    [self.delegate toHome:[self class]];
}
@end
//各自类实现具体的行为
@implementation CarFactory
-(int)shouldPayMoney{
    return 50;
}
-(void)run{
    [super run];
    NSLog(@"car to home");
}
@end
@implementation AirportFactory
-(int)shouldPayMoney{
    return 1000;
}
-(void)run{
    [super run];
    NSLog(@"fly to home");
}
@end
@implementation BoatFactory
-(int)shouldPayMoney{
    return 300;
}
-(void)run{
    [super run];
    NSLog(@"boat to home");
}
@end
@implementation BusFactory
-(int)shouldPayMoney{
    return 10;
}
-(void)run{
    [super run];
    NSLog(@"bus to home");
}
@end
@implementation BycicleFactory
-(int)shouldPayMoney{
    return 0;
}
-(void)run{
    [super run];
    NSLog(@"run to home");
}
@end
@implementation TaxiFactory
-(int)shouldPayMoney{
    return 100;
}
-(void)run{
    [super run];
    NSLog(@"go to home");
}
@end

这样，我们的一个生产工厂就完成了，在外面，我们只需要知道一个类，我们的抽象父类，就可以实现个子类的行为，示例如下：

- (void)viewDidLoad {
    [super viewDidLoad];
    TramsPortationFactory * tool = [TramsPortationFactory buyTool:car];
    tool.delegate=self;
    [tool run];
    NSLog(@"花了:%d钱",[tool shouldPayMoney]);
    TramsPortationFactory * tool2 = [TramsPortationFactory buyTool:airport];
    tool2.delegate=self;
    [tool2 run];
    NSLog(@"花了:%d钱",[tool2 shouldPayMoney]);
     
     
}
-(void)toHome:(Class)class{
    NSLog(@"%@",NSStringFromClass(class));
}