IOS面试题(设计模式相关) --- 工厂设计模式

OC面试题目合集地址

问题1: ios什么是简单工厂设计模式

• 简单工厂模式 Simple Factory Pattern ：专门定义一个类（工厂类）来负责创建其他类的实例。可以根据创建方法的参数来返回不同类的实例，被创建的实例通常都具有共同的父类。

结合例子看一下:

例子

• 工厂 Factory：角色, 接受客户端Client 的请求，负责创建相应的产品对象。
• 抽象产品 Abstract Product: 角色, 工厂模式所创建对象的父类或拥有的共同接口。
• 具体产品 ConcreteProduct: 对象, 工厂模式所创建的对象

例子代码

结合代码看一下:

例子

SimpleFactory.h

#import <Foundation/Foundation.h>
#import "Cola.h"
#import "CocaCola.h"
#import "PepsiCola.h"

typedef NS_ENUM(NSInteger, SimpleFactoryColeType) {
    SimFacCocaCola,
    SimFacPepsiCola
};

NS_ASSUME_NONNULL_BEGIN

@interface SimpleFactory : NSObject

// 工厂：接受客户端的请求，通过请求负责创建相应的产品对象。
+ (Cola *)factoryProductCola:(SimpleFactoryColeType)colaType;

@end

NS_ASSUME_NONNULL_END

SimpleFactory.m

#import "SimpleFactory.h"

@implementation SimpleFactory

// 工厂：接受客户端的请求，通过请求负责创建相应的产品对象。
+ (Cola *)factoryProductCola:(SimpleFactoryColeType)colaType {
    
   // 通常枚举, if也可
    switch (colaType) {
        case SimFacCocaCola:
            return [CocaCola new];
            
        case SimFacPepsiCola:
            return [PepsiCola new];
            
        default:
            return nil;
            break;
    }
    
}

@end

CocaCola

#import "CocaCola.h"

@implementation CocaCola

- (void)sayCola {
    
    NSLog(@"sayCocaCola");
}

@end

PepsiCola

#import "PepsiCola.h"

@implementation PepsiCola


- (void)sayCola {
    NSLog(@"sayPepsiCola");
}

@end

运行结果

由此可以看出简单工厂的优缺点:

• 优点:

  • 工厂类/方法集中管理, 实现代码简洁性
  • 根据约定好的参数就可以获取所需要的对象，而不需要知道其创建的细节。减少了系统的耦合度
  • client 客户端只需要知道具体产品类所对应的参数即可，减少开发者的记忆成本。

• 缺点:

  • 在产品类型较多时，有可能造成工厂逻辑过于复杂
  • 具体产品只能为固定的父类上进行延伸, 难以扩展
  • 如果业务上添加新产品的话，就需要修改工厂类原有的判断逻辑，这其实是违背了开闭原则的。

---

问题2: ios什么是工厂设计模式

• 工厂模式 Factory Method Pattern ：工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，即通过不同的工厂子类来创建不同的产品对象。

例子

其实工厂模式具有OOP的多态性，将工厂和产品都抽象出一个基类，在基类中定义统一的接口，然后在具体的工厂中创建具体的产品。比起简单工厂，工厂方法就不需要判断，耦合度低了不少。

例子代码

Factory.h

#import <Foundation/Foundation.h>
#import "Cola.h"
#import "CocaCola.h"
#import "PepsiCola.h"

NS_ASSUME_NONNULL_BEGIN

@interface Factory : NSObject

@end

@interface CocaColaFactory : Factory

+ (Cola *)productCocaCola;

@end

@interface PepsiColaFactory : Factory

+ (Cola *)productPepsiCola;

@end

Factory.m

#import "Factory.h"

@implementation Factory

@end

@implementation CocaColaFactory

+ (Cola *)productCocaCola {
    
    Cola *cola = [[CocaCola alloc] init];
    return cola;
}

@end


@implementation PepsiColaFactory

+ (Cola *)productPepsiCola {
    Cola *cola = [[PepsiCola alloc] init];
    return cola;
    
}

@end

CocaCola

#import "CocaCola.h"

@implementation CocaCola

- (void)sayCola {
    
    NSLog(@"sayCocaCola");
}

@end

PepsiCola

#import "PepsiCola.h"

@implementation PepsiCola


- (void)sayCola {
    NSLog(@"sayPepsiCola");
}

@end

例子

由此可以看出工厂模式的优缺点:

• 优点：

  • 满足了类之间的层次关系, 降低了工厂类的内聚
  • 无须修改客户端和其他的具体工厂和具体产品，只添加一个具体工厂和与其对应的具体产品就可以了，符合开闭原则。

• 缺点：

  • 工厂模式每次需要一个新的产品，就需要新建一个具体工厂来生成新的产品
  • 当多个产品时, 类的个数将成对增加，增加复杂度。

---

问题3: ios什么是抽象工厂模式

• 抽象工厂模式 Abstract Factory Pattern: 一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象, 也可以理解成一个超级工厂创建其他工厂。提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

其中产品族: 是指位于不同产品等级结构，功能相关联的产品组成的家族。例如:
百事瓶盖、百事瓶子、百事饮料水组成一个家族，可口瓶盖、可口瓶子、可口饮料水组成另一个家族。而这两个家族有三个产品等级：瓶盖、瓶子、饮料水。一个等级结构是由相同的结构的产品组成。

例子

例子代码

AbstractFactory.h

#import <Foundation/Foundation.h>
#import "ColaThemeFactory.h"

typedef NS_ENUM(NSInteger, AbstractFactoryColeType) {
    CocaThemeFactoryType,
    PepsiThemeFactoryType
};


NS_ASSUME_NONNULL_BEGIN

@interface AbstractFactory : NSObject

+ (ColaThemeFactory *)factoryWithModel:(AbstractFactoryColeType)modelType;

@end

NS_ASSUME_NONNULL_END

AbstractFactory.m

#import "AbstractFactory.h"
#import "ColaThemeFactory.h"
#import "PepsiThemeFactory.h"

@implementation AbstractFactory


+ (ColaThemeFactory *)factoryWithModel:(AbstractFactoryColeType)modelType {
    
    if (modelType == PepsiThemeFactoryType) {
        return  [[PepsiThemeFactory alloc] init];
    }else if (modelType == CocaThemeFactoryType) {
        return  [[ColaThemeFactory alloc] init];
    }
    
    return nil;
    
}

@end

ColaThemeFactory.h

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface ColaThemeFactory : NSObject


- (void)productCola;
- (void)productCap;
- (void)productSparklingWater;
- (void)productBottle;

@end

NS_ASSUME_NONNULL_END

ColaThemeFactory.m

#import "ColaThemeFactory.h"

@implementation ColaThemeFactory


- (void)productCola {
    
    [self productBottle];
    [self productSparklingWater];
    [self productCap];
}

@end

PepsiThemeFactory 与CocaThemeFactory一样只是打印文字不同, 只写一个, 详细可见评论区demo

PepsiThemeFactory.h

#import "ColaThemeFactory.h"

NS_ASSUME_NONNULL_BEGIN

@interface PepsiThemeFactory : ColaThemeFactory

- (void)productCap;
- (void)productSparklingWater;
- (void)productBottle;

@end

NS_ASSUME_NONNULL_END

PepsiThemeFactory.m

#import "PepsiThemeFactory.h"

@implementation PepsiThemeFactory

- (void)productCap {
    NSLog(@"生产百事瓶盖");
}

- (void)productSparklingWater {
    NSLog(@"生产百事饮料水");
}

- (void)productBottle {
    NSLog(@"生产百事瓶子");
}


@end

例子

抽象工厂模式	工厂模式
派生多个具体工厂类	派生多个具体产品类
可以产生多个系列的产品	一个工厂只能产生一种产品
必须修改父类的接口才能支持新的产品	子类化创建者并重载工厂方法以创建新产品

由此可以看出抽象工厂模式的优缺点:

• 优点：

  • 分离接口和实现
  • 使切换产品族变得容易, 同时一个产品族中的多个对象被设计成一起，保证客户端始终只使用同一个产品族中的对象。

• 缺点：

  • 整体复杂度高
  • 产品族扩展困难，需要修改抽象工厂的接口