工厂方法(Factory Method)

工厂方法

一般情况下，工厂模式分为：简单工厂、工厂方法和抽象工厂。

简单工厂模式(Simple Factory)

简单工厂并不是GoF的23种设计模式的一种，是工厂方法的一种特例，也称为静态工厂方法模式(Static Factory Method Pattern)。

简单工厂模式.jpg

角色和职责

1. 工厂(Creator)
   简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。Creator工厂类可以被外界直接调用，创建所需的产品对象。
2. 抽象(AbstractProduct)
   简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3. 具体产品(ConCreteProduct)
   简单工厂模式所创建的具体实例对象。

代码示例

#import <Foundation/Foundation.h>

@interface AbstractProduct : NSObject
- (void)anOperation;
@end
@implementation AbstractProduct
@end

@interface AProduct : AbstractProduct
@end

@implementation AProduct
- (void)anOperation {
    NSLog(@"A Product");
}
@end

@interface BProduct : AbstractProduct
@end

@implementation BProduct
- (void)anOperation {
    NSLog(@"B Product");
}
@end

@interface Factory : NSObject
- (AbstractProduct *)createProduct:(NSString *)name;
@end
@implementation Factory
- (AbstractProduct *)createProduct:(NSString *)name {
    if ([name isEqualToString:@"A"]) {
        return [[AProduct alloc] init];
    }else if ([name isEqualToString:@"B"]) {
        return [[BProduct alloc] init];
    }
    return nil;
}
@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Factory *f1 = [[Factory alloc] init];
        AbstractProduct *product1 = [f1 createProduct:@"A"];
        [product1 anOperation];
        
        AbstractProduct *product2 = [f1 createProduct:@"B"];
        [product2 anOperation];
        
    }
    return 0;
}

优缺点

在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以根据工厂类去创建所需的实例，而无需了解这些对象是如何创建的以及如何组织的。有利于软件体系结构的优化。

不难发现简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品不断增多时，可能要求工厂类也要作出相应的修改，扩展性并不好。违反了开闭原则。

工厂方法(Factory Method)

意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式使得一个类的实例化延迟到其子类。

利用多态去掉if逻辑分支，对上面的代码进行重构。

工厂方法.jpg

代码实例

#import <Foundation/Foundation.h>

@interface AbstractProduct : NSObject
- (void)anOperation;
@end
@implementation AbstractProduct
@end

@interface AProduct : AbstractProduct
@end

@implementation AProduct
- (void)anOperation {
    NSLog(@"A Product");
}
@end

@interface BProduct : AbstractProduct
@end

@implementation BProduct
- (void)anOperation {
    NSLog(@"B Product");
}
@end

@interface CProduct : AbstractProduct
@end

@implementation CProduct
- (void)anOperation {
    NSLog(@"C Product");
}
@end

@interface AbstractFactory : NSObject
- (AbstractProduct *)createProduct;
@end
@implementation AbstractFactory
@end

@interface AFactory : AbstractFactory
@end
@implementation AFactory
- (AbstractProduct *)createProduct {
    return [[AProduct alloc] init];
}
@end

@interface BFactory : AbstractFactory
@end
@implementation BFactory
- (AbstractProduct *)createProduct {
    return [[BProduct alloc] init];
}
@end

@interface CFactory : AbstractFactory
@end
@implementation CFactory
- (AbstractProduct *)createProduct {
    return [[CProduct alloc] init];
}
@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        AbstractFactory *f1 = nil;
        f1 = [[AFactory alloc] init];
        
        AbstractProduct *product1 = [f1 createProduct];
        [product1 anOperation];
        
        f1 = [[BFactory alloc] init];
        AbstractProduct *product2 = [f1 createProduct];
        [product2 anOperation];
        
        f1 = [[CFactory alloc] init];
        AbstractProduct *product3 = [f1 createProduct];
        [product3 anOperation];
        
    }
    return 0;
}

优点

去掉if分支逻辑也实现了工厂类和产品类的解耦。更符合开闭原则。

缺点

只能生产单一的产品，不能生产产品族。创建一个产品，对应的也要创建一个生产该产品的工厂(类或过多)。