简单工厂模式、工厂模式、抽象工厂模式的解析-iOS

简单工厂模式、工厂模式、抽象工厂模式的解析-iOS

其他设计模式的介绍

1、简单工厂模式、工厂模式、抽象工厂模式的解析-iOS
2、建造者模式的解析-iOS
3、单例模式的解析-iOS
4、原型模式的解析-iOS
5、代理模式的解析-iOS
6、适配器模式的解析-iOS
7、装饰器模式的解析-iOS
8、外观模式的解析-iOS
9、桥接模式的解析-iOS
10、组合模式的解析-iOS

简单工厂模式

我们先来理解一下简单的工程模式：
比如：小明有一家工厂可以生存2种原料。这个时候如果客户需要再需要另外一种原料，这个时候小明可以再生产一种原料。就是3种原料了。
简单工厂类内部实现

#import "Factory.h"
@implementation Factory
-(void)ProductCommodity:(ProductType)ProductType{
    switch (ProductType) {
        case ProductA:
            [self ProductA];
            break;
        case ProductB:
            [self ProductB];

            break;
        case ProductC:
            [self ProductC];
            break;

        default:
            break;
    }
}
-(void)ProductA{
    NSLog(@"生产了A原料");
}
-(void)ProductB{
    NSLog(@"生产了B原料");
}
-(void)ProductC{
    NSLog(@"生产了C原料");
}

客户提取原料的代码

//工厂模式
    Factory *factory = [[Factory alloc]init];
    [factory ProductCommodity:ProductA];

上述的简单的工厂模式在于，一个工厂生产多种商品，如果，还有要生产其他的商品我们就得去改变生产的代码逻辑，如果生产的商品很多的话，我们就需要不断的去加生产不同商品的逻辑。
如果哪天这个工厂发生了一些问题，这个工厂里面生产的一些原料就不能完成。
他还违背了“开放-封闭原则”，一旦客户需要新的原料，我们就不得不去修改工厂类的原有的逻辑。
比如生产D原料，就需要添加增加生产D原料的代码逻辑，如下所示：

    switch (ProductType) {
        case ProductA:
            [self ProductA];
            break;
        case ProductB:
            [self ProductB];

            break;
        case ProductC:
            [self ProductC];
            break;

        case ProductD:
            [self ProductD];
            break;

        default:
            break;
    }

工厂模式

然后就在简单的工厂模式下改良了，就形成了工厂模式。
例子：小明有一家工厂生产原料A，这个时候客户还需要另外一种原料，小明在上家工厂没有办法生产B原料，小明就重新开了一家工厂，生产B原料来提供给客户。这个就是工厂模式。具体代码如下：

A工厂代码的代码

#import "FactoryA.h"

@implementation FactoryA
-(void)ProductA{
    NSLog(@"生产了A原料");
}

@end

B工厂代码的代码

#import "FactoryB.h"

@implementation FactoryB
-(void)ProductB{
    NSLog(@"生产了B原料");
}

@end

客户需求原料A和原料B的代码的代码

   //工厂模式
    FactoryA *factoryA = [[FactoryA alloc] init];
    [factoryA ProductA];
    FactoryB *factoryB = [[FactoryB alloc] init];
    [factoryB ProductB];

工厂模式，更加符合“开放-封闭原则”，每新增一种原料就开一家工厂，2个工厂之间互相不干涉。
工厂模式符合“单一职责原则”，每个工厂只负责生产自己的产品就够了。
但是他每新添加一种原料就需要新开一个工厂，这样造成需要管理的每个工厂的类很多，没有一个集体的管理类，这样就衍生出了抽象工厂类。

抽象工厂模式

抽象工厂模式可以解决上述工厂模式中的每个工厂自己管理自己没有一个统一的管理类比如看下面的例子。
例子：比如小明在A地又一家工厂生产A罐头，在B地有家工厂生产B饮料，（可能会有人问为什么不在一家工厂生产A罐头、B饮料，这个细节大家就不要纠结了，只是举个例子??），现在A地的客户需要生产B饮料的塑料瓶子，而B地需要生产A罐头的玻璃瓶子，这个时候，不可能再再在A、B地再分别开一家生产塑料瓶子和玻璃瓶子的工厂，这样很浪费资源。我们可以分别生产A罐头，A玻璃瓶子，B饮料，B塑料瓶子。在抽象一个抽象的工厂，他只负责调货，不负责具体的生产细节。
具体看代码

生产A罐头的原料的代码

#import "FactoryRawMaterialA.h"

@implementation FactoryRawMaterialA
-(void)productRawMaterialA{
    NSLog(@"生产A罐头的原料");
}

生产A玻璃瓶子的代码

#import "FactoryBottleA.h"

@implementation FactoryBottleA
-(void)productBottleA{
    NSLog(@"生产了A玻璃瓶子");
}
@end

生产B饮料的原料的代码

#import "FactoryRawMaterialB.h"

@implementation FactoryRawMaterialB
-(void)productRawMaterialB{
    NSLog(@"生产A饮料的原料");
}

@end

生产B塑料瓶子的代码

#import "FactoryBottleB.h"

@implementation FactoryBottleB
-(void)productBottleB{
    NSLog(@"生产了B塑料瓶子");
}

@end

抽象工厂获取A罐头、B塑料瓶子和B饮料、A玻璃瓶子的代码

#import "AbstractFactory.h"
#import "FactoryBottleA.h"
#import "FactoryBottleB.h"
#import "FactoryRawMaterialA.h"
#import "FactoryRawMaterialB.h"

@implementation AbstractFactory
//A客户需要A罐头，B塑料瓶子
-(void)productCommodityForA{
    //A罐头
    FactoryRawMaterialA *factoryRawMaterialA = [[FactoryRawMaterialA alloc]init];
    [factoryRawMaterialA productRawMaterialA];

    //B塑料瓶子
    FactoryBottleB *factoryBottleB = [[FactoryBottleB alloc] init];
    [factoryBottleB productBottleB];

}
//B客户需要B饮料，A玻璃瓶子
-(void)productCommodityForB{
    //B饮料
    FactoryRawMaterialB *factoryRawMaterialB = [[FactoryRawMaterialB alloc]init];
    [factoryRawMaterialB productRawMaterialB];

    //A玻璃瓶子
    FactoryBottleA *factoryBottleA = [[FactoryBottleA alloc] init];
    [factoryBottleA productBottleA];

}

@end

客户提取商品的代码

    //抽象工厂模式
    AbstractFactory *abstractFactory = [[AbstractFactory alloc] init];
    //A客户需要A罐头，B塑料瓶子
    [abstractFactory productCommodityForA];
    //B客户需要B饮料，A玻璃瓶子
    [abstractFactory productCommodityForB];

抽象工厂更加符合我们的“开放-封闭原则”，每需要一种商品，只要增加我们生产商品的相应子类和到具体工厂中组装变成客户需要的商品。
也符合我们单一职责原则，每个子类工厂只负责生产一种商品，组装销售只需要交给我们的具体工厂去完成就行。
抽象工厂降低了每个工厂的耦合性，具体组装的任务都放到了具体工厂中去了，每个子类工厂之间没有耦合。

总结

如果有写的不正确或者侵权的，希望大家给我提出来，我会及时修改。谢谢大家。