大话设计模式之工厂方法模式(工厂模式)

工厂方法模式：

定义：

工厂方法模式，定义了一个用于创建对象的接口，让子类决定实例化那个类。工厂方法使一个类的实例化延迟到其子类

简单的工厂模式：

其结构图为：

 

我们就举个计算器的例子

首先要有个计算类 Calc.h文件

#import <Cocoa/Cocoa.h>

@interface Calc : NSObject
@property(nonatomic,assign)int num1;
@property(nonatomic,assign)int num2;

-(int)calculer;

@end

Calc.m文件

#import "Calc.h"

@implementation Calc
-(int)calculer{
    return 0;
}
@end

加法类 Add.h

#import "Calc.h"

@interface Add : Calc
@end

加法类 Add.m文件

#import "Add.h"

@implementation Add
-(int)calculer{

    return self.num1+self.num2;
}
@end

减法类 Sub.h文件

#import "Calc.h"

@interface Sub : Calc

@end

减法类 Sub.m文件

#import "Sub.h"

@implementation Sub
-(int)calculer{
    return self.num1-self.num2;
}
@end

工厂类SimpleFactory.h文件

#import <Foundation/Foundation.h>
#import "Calc.h"
#import "Add.h"
#import "Sub.h"
@interface SimpleFactory : NSObject
-(Calc *)Operation:(char) ch;
@end

工厂类SimpleFactory.m文件

#import "SimpleFactory.h"

@implementation SimpleFactory
-(Calc *)Operation:(char)ch{
    Calc *calc;
    switch (ch) {
        case '+':
            calc=[[Add alloc]init];
            break;
        case '-':
            calc=[[Sub alloc]init];
            break;
        default:
            calc=[[Calc alloc]init];
            break;
    }
    
    return calc;
    
    
}
@end

客户端代码

#import <Foundation/Foundation.h>
#import "SimpleFactory.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        SimpleFactory *simale=[[SimpleFactory alloc]init];
        
        Calc *calc=[simale Operation:'+'];
        
        calc.num1=100;
        calc.num2=230;
        
        NSLog(@"%d",[calc calculer]);
    }
    return 0;
}

运行结果

工厂模式实现

 

 

把简单工厂类里面的工厂类SimpleFactory.m删除，新增加一个工厂类：IFactory

IFactory.h文件

#import <Foundation/Foundation.h>
#import "Operation.h"
@interface IFactory : NSObject
-(Operation *)CreatedOperation;
@end

IFactory.m文件

#import "IFactory.h"
#import "Operation.h"
@implementation IFactory
-(Operation *)CreatedOperation{
    return 0;
}
@end

加法工厂类

AddFactory.h文件

#import <Foundation/Foundation.h>
#import "IFactory.h"
#import "Add.h"
@interface AddFactory : IFactory

@end

AddFactory.m文件

#import "AddFactory.h"
@implementation AddFactory
-(Operation *)CreatedOperation{
    return [Add new];
}
@end

减法工厂类

SubFacory.h文件

#import <Foundation/Foundation.h>
#import "IFactory.h"
#import "Sub.h"
@interface SubFacory :IFactory

@end

SubFacory.m文件

#import "SubFacory.h"

@implementation SubFacory
-(Operation *)CreatedOperation{
    return [Sub new]
}
@end

客户端代码

#import <Foundation/Foundation.h>
#import "AddFactory.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        IFactory *operFactory=[AddFactory new];
        Operation *oper=[operFactory CreatedOperation];
        oper.numberA=1;
        oper.numberB=2;
        NSLog(@"%f",[oper opera]);
    }
        return 0;
}

简单的工厂模式和工厂模式的比较

简单工厂模式的最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行，你想要加功能，本来是改工厂类的，而现在时修改客户端

工厂模式的优缺点

工厂方法模式是简单工厂模式的进一步抽象的推广，工厂方法模式保持了简单工厂模式的优点，而且克服了他的缺点

缺点：由于每增加一个产品，就需要增加一个产品工厂的类，增加了额外的开发量