【iOS开发】—— 工厂模式

设计模式的六大原则

1. 单一职责原则：一个类只承担一个职责。
2. 开闭原则： 对软件实体的改动，最好用扩展而非修改的方式。
3. 里氏替换原则：子类可以扩展父类的方法， 换句话说：一个对象在其出现的任何地方，都可以用子类实例做替换，并且不会导致程序的错误。
4. 接口隔离原则：对象不应被强迫依赖它不使用的方法，使用多个专门的协议， 而不是一个庞大臃肿的协议，例如：UITableViewDelegate、UITableViewDataSource。一个类实现的接口中，包含了它不需要的方法。将接口拆分成更小和更具体的接口，有助于解耦，从而更容易重构、更改。
5. 依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。
6. 迪米特法则：一个对象对另一个对象了解得越多，那么，它们之间的耦合性也就越强，当修改其中一个对象时，对另一个对象造成的影响也就越大。所以：一个对象应该对其他对象保持最少的了解，实现低耦合、高内聚。

工厂模式

工厂模式属于创建型模式，主要是用来创建对象的时候使用。

简单工厂模式

工厂类

工厂类通常包含一个静态方法（类方法），由该方法根据输入类型负责创建具体的产品（对象）。

抽象产品基类（接口）

它的作用是降低客户端和具体产品之间的耦合度。而且符合了开闭原则，以后需要加入新车型，客户端调用的代码也基本无需修改。

具体产品类

真正实现业务逻辑的子类。

缺点

1. 工厂类只有一个，且静态的工厂方法无法由子类继承，所以工厂的扩展受到限制。
2. 工厂方法里除了创建对象的代码，还有大量的判断逻辑（if-else）混在里面，方法会变得越来越臃肿。

代码举例：

主界面设置一个TextField和一个button 然后在button的点击事件中调用工厂方法进行创建不同的类的实例:

创建一个工厂PhoneFactory，工厂通过传递的NSString*类型的值进行判断所属类型从而创建类的实例，我这里通过简单的判断值为哪一个手机进行判断，创建对应实例：

#import "PhoneFactory.h"
#import "iPhone.h"
#import "XiaoMi.h"
#import "Oppo.h"
#import "Vivo.h"
#import "HuaWei.h"
@implementation PhoneFactory
+ (id)createPhone:(NSString*)phoneType {
    NSArray* array = @[@"iPhone", @"XiaoMi", @"Oppo", @"Vivo", @"HuaWei"];
    switch ([array indexOfObject:phoneType]) {
        case 0:
            return [[iPhone alloc] init];
            break;
        case 1:
            return [[XiaoMi alloc] init];
            break;
        case 2:
            return [[Oppo alloc] init];
            break;
        case 3:
            return [[Vivo alloc] init];
            break;
        case 4:
            return [[HuaWei alloc] init];
            break;
        default:
            break;
    }
    return nil;
}
@end

其余几个产品类都像下面这样写：

当输入的字符串不同的时候，创建的类也不同：

工厂方法模式

抽象工厂类、具体工厂子类

工厂方法模式在简单工厂模式的基础上演变为抽象出一个工厂父类，然后用不同的工厂子类来生成各自的产品。

缺点

该模式下产品和工厂的可扩展性都增强了，但是也随之而来的是可能会出现工厂类过多的问题。一般可以和简单工厂模式结合使用。

抽象工厂模式

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类。抽象工厂模式里每个工厂都会生产多种产品，但不同工厂生产的产品属于不同的系列。抽象工厂模式可以用来解决多产品族的问题。

缺点

1. 增加新的产品种类困难，它需要修改抽象工厂的接口。
2. 代码结构比较复杂。

应用场景

需要创建一组对象，并需要切换不同的系列时。

举例

现在我们要创建两个工厂，一个是苹果厂，一个是谷歌厂，同时苹果厂可以生产苹果手机和苹果手表，谷歌厂可以生产安卓手机和安卓手表，同时每部手机不光可以打电话，发短信，还都有自己独特的功能，苹果手机可以指纹识别，安卓可以主题定制。
需要先创建工厂基类。

@implementation BaseFactory

- (BasePhone *)createPhone {
    
    return nil;
}
- (BaseWatch *)createWatch {
    
    return nil;
}
@end

然后根据基类分别创建苹果厂和谷歌厂。

@implementation AppleFactory

- (BasePhone *)createPhone {
    
    return [[IPhone alloc] init];
}

- (BaseWatch *)createWatch {
    
    return [[IWatch alloc] init];
}

@end

@implementation GoogleFactory

- (BasePhone *)createPhone {
    
    return [[Android alloc] init];
}

- (BaseWatch *)createWatch {

    return [[AndroidWatch alloc] init];
}
@end

然后创建手机基类。

@interface BasePhone : NSObject

@end
@implementation BasePhone

- (void)phoneCall {
    
}
- (void)sendMessage {
    
}
@end

根据手机基类创建不同的手机。

@implementation IPhone

- (void)phoneCall {
    
    NSLog(@"iPhone phoneCall");
}

- (void)sendMessage {
    
    NSLog(@"iPhone sendMessage");
}

- (void)fingerprintIndetification {
    
    NSLog(@"iPhone fingerprintIndetification");
}


@end

@implementation Android

- (void)phoneCall {
    
    NSLog(@"Android phoneCall");
}

- (void)sendMessage {
    
    NSLog(@"Android sendMessage");
}

- (void)customTheme {
    
    NSLog(@"Android customTheme");
}


@end

创建不同工厂的工厂管理类。

typedef NS_ENUM(NSUInteger, KFactoryType) {
    
    KApple,
    KGoogle
};

@interface FactoryManager : NSObject


/**
 获取工厂

 @param factoryType 工厂类型
 @return 创建出的工厂
 */
+ (BaseFactory *)factoryWithBrand:(KFactoryType)factoryType;

@end
+ (BaseFactory *)factoryWithBrand:(KFactoryType)factoryType {
    BaseFactory *factory = nil;
    
    if (factoryType == KApple) {
        
        factory = [[AppleFactory alloc] init];
        
    } else if (factoryType == KGoogle) {
        
        factory = [[GoogleFactory alloc] init];
    }
    
    return factory;

}

@end

那么下面就是来使用了，屏蔽内部实现，通过不同工厂类组装成的抽象工厂模式

    // 获取工厂
    BaseFactory *googleFactory = [FactoryManager factoryWithBrand:KGoogle];
    
    // 创建商品
    Android *androidPhone = (Android *)[googleFactory createPhone];
    BaseWatch *androidWatch = [googleFactory createWatch];
    [androidPhone phoneCall];
    //定制主题
    [androidPhone customTheme];
    
    
    // 获取工厂
    BaseFactory *appleFactory = [FactoryManager factoryWithBrand:KApple];
    
    // 创建商品
    IPhone *applePhone = (IPhone *)[appleFactory createPhone];
    BaseWatch *appleWatch = [appleFactory createWatch];

    [applePhone phoneCall];
    //指纹识别
    [applePhone fingerprintIndetification];

我们可以看到 抽象工厂与工厂模式不同，抽象工厂的创建方式是对象组合创建抽象产品，而不是工厂模式中的类继承创建抽象产品
为什么说是组合创建抽象产品，我们可以看到每个不同的工厂里都有两种不同的创建方法，得到不同的对象.

demo:工厂模式。