工厂模式在父类里声明（可实现）创建对象的一个接口，让子类决定实例化哪个类，也就是说让一个类的实例化延迟到子类中生产。

工厂模式一般用于在不同地方创建对象和项目部署依赖多个数据库的时候。

工厂模式有三种，简单工厂，工厂方法， 抽象工厂。

简单工厂就是：工厂模式所创建的对象都是具体产品的实例。从以下的实例来看。

我以一个简单的计算器Demo来介绍一下简单工厂。

首先搭建界面如图：

创建以下类：

Operation.h

#import <Foundation/Foundation.h>

@interface Operation : NSObject

@property(nonatomic,assign)double firstNum;

@property(nonatomic,assign)double secondNum;

-(double)operate;

@end

Operation.m

#import "Operation.h"

@implementation Operation

-(double)operate{

return 0;

}

@end

Add.h

#import "Operation.h"

@interface Add : Operation

@end

Add.m

#import "Add.h"

@implementation Add

-(double)operate{

double result=0;

result=self.firstNum+self.secondNum;

return result;

}

@end

Minus.h，Minus.m，Multiplication.h，Multiplication.m，Division.h，Division.m与Add.h Add.m相类似。

创建工厂类

OperationFactory.h

#import <Foundation/Foundation.h>

#import "Add.h"

#import "Multiplication.h"

#import "Minus.h"

#import "Division.h"

#import "Operation.h"

@interface OperationFactory : NSObject

-(Operation*)runOperation:(NSString*)operatorStr;

@end

OperationFactory.m

#import "OperationFactory.h"

@implementation OperationFactory

-(Operation*)runOperation:(NSString*)operatorStr{

Operation *op=nil;

if ([operatorStr isEqualToString:@"+"]) {

op=[[Add alloc]init];

}

else if ([operatorStr isEqualToString:@"-"]){

op=[[Minus alloc]init];

}

else if ([operatorStr isEqualToString:@"*"]){

op=[[Multiplication alloc]init];

}

else if ([operatorStr isEqualToString:@"/"]){

op=[[Division alloc]init];

}

return op;

}

@end

实现代码如图

运行之后就能够做一些简单的计算了，并未考虑除数等其他因素，只是为了简单的介绍一下简单工厂。

接下来来说说工厂方法，工厂方法体现一种扩展的对象创建方式，很好地符合了开放封闭原则，也叫做虚构造器。说白了工厂方法就是使用了OOP的多态性，通过父类的创建方法创建出不同的子类对象。

我还是通过一个飞机工厂的Demo来实例解释一下工厂方法。

需要创建6个类，其中Bomber和helicopter类是Air的子类，BomberFactory和helicopterFactory类是AirFactory的子类。

Air.h

#import <Foundation/Foundation.h>

@interface Air : NSObject

-(void)fire;

@end

Air.m

import "Air.h"

@implementation Air

-(void)fire{

NSLog(@"Air fire");

}

@end

bomber.h

#import "Air.h"

@interface bomber : Air

-(void)fire;

@end

bomber.m

#import "bomber.h"

@implementation bomber

-(void)fire{

NSLog(@"bomber fire");

}

@end

helicopter.h

#import "Air.h"

@interface helicopter : Air

-(void)fire;

@end

helicopter.m

#import "helicopter.h"

@implementation helicopter

-(void)fire{

NSLog(@"helicopter fire");

}

@end

AirFactory.h

#import <Foundation/Foundation.h>

@class Air;

@interface AirFactory : NSObject

-(Air*)productAirs;

@end

AirFactory.m

#import "AirFactory.h"

@implementation AirFactory

-(Air*)productAirs{

return nil;

}

@end

bomberFactory.h

#import "AirFactory.h"

@interface bomberFactory : AirFactory

-(Air*)productAirs;

@end

bomberFactory.m

#import "bomberFactory.h"

#import "bomber.h"

@implementation bomberFactory

-(Air*)productAirs{

return [[bomber alloc]init];

}

@end

helicopterFactory.h

#import "AirFactory.h"

@interface helicopterFactory : AirFactory

-(Air*)productAirs;

@end

helicopterFactory.m

#import "helicopterFactory.h"

#import "helicopter.h"

@implementation helicopterFactory

-(Air*)productAirs{

return [[helicopter alloc]init];

}

@end

最后实现代码：

#import "ViewController.h"

#import "Air.h"

#import "AirFactory.h"

#import "bomber.h"

#import "bomberFactory.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {

[super viewDidLoad];

AirFactory *airf=[[bomberFactory alloc]init];

Air *a=[airf productAirs];

[a fire];

}

- (void)didReceiveMemoryWarning {

[super didReceiveMemoryWarning];

// Dispose of any resources that can be recreated.

}

运行结果为

bomber fire

工厂方法将类与类之间更好的分层，这样有利于程序功能的补充，代码也变得简洁干净。

最后说说抽象工厂，我的理解就是抽象工厂是一种生产“类“的工厂模式，例如生产UIButton，UIView等UI控件。抽象工厂和工厂方法的区别在于抽象工厂是需要创建一个或多个对象类的时候被使用，而工厂方法则是创建一个具体实例的时候被使用。