设计模式02之桥接-工厂-享元模式

1.桥接模式

定义

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

原理

抽象层与实现层相分离, 抽象层定义了供客户端调用的抽象接口, 实现层提供了具体的逻辑. 实现类的引用被封装到抽象层的实例中,桥接就形成，降低耦合性

理解

这里写图片描述

原先一个类型的电视机对应一个遥控器，利用桥接模式就是把每个遥控器共有的部分抽取出来，定义遥控器

特点

  1. 将依赖具体的实现, 改为依赖抽象. 起到一个松耦合的作用
  2. 分离了接口和实现部分
  3. 提高了扩展性

demo

就以上面的电视机遥控器为案例，这里有两个电视机xiaomi和kj，两个遥控器XiaoMiRemote和KJRemote，每个遥控器有几个方法

桥接前

XiaoMiTV


@implementation XiaoMiTV

- (void)loadCommand:(NSString *)command {
    // 点击了之后, 需要实现的业务逻辑
    NSLog(@"您按的是:----%@",command);
}
@end

XiaoMiRemote

#import "XiaoMiRemote.h"

@implementation XiaoMiRemote
- (void)up {
    [self.TV loadCommand:@"up"];
}

- (void)down {
    [self.TV loadCommand:@"down"];
}

- (void)left {
    [self.TV loadCommand:@"left"];
}

- (void)right {
    [self.TV loadCommand:@"right"];
}
@end

KJTV

@implementation KJTV

- (void)loadCommandKJ:(NSString *)commandKJ {
    // 点击了之后, 需要实现的业务逻辑
    NSLog(@"您按的是KJ:----%@",commandKJ);
}

@end

KJRemote


@implementation KJRemote
- (void)up {
    [self.TV loadCommandKJ:@"up"];
}

- (void)down {
    [self.TV loadCommandKJ:@"down"];
}

- (void)left {
    [self.TV loadCommandKJ:@"left"];
}

- (void)right {
    [self.TV loadCommandKJ:@"right"];
}


@end

调用的viewController


#import "ViewController.h"
#import "XiaoMiTV.h"
#import "XiaoMiRemote.h"

#import "KJTV.h"
#import "KJRemote.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    // 小米电视
    XiaoMiTV *TV = [[XiaoMiTV alloc] init];
    XiaoMiRemote *remote = [[XiaoMiRemote alloc] init];
    remote.TV = TV;
    [remote up];
    [remote down];
    
    // KJ电视
    KJTV *TV2 = [[KJTV alloc] init];
    KJRemote *remote2 = [[KJRemote alloc] init];
    remote2.TV = TV2;
    [remote2 up];
    [remote2 down];

}

@end

桥接模式抽取

思路

把遥控器抽象出一个父类, 把电视机也抽象出一个父类。用抽象的控制器对抽象的电视机类进行引用,具体的实现由他们的子类来做.

这里写图片描述

抽象出的TV类

@interface TV : NSObject

// 电视机提供给外界的方法
- (void)loadCommand:(NSString *)command;

@end


#import "TV.h"

@implementation TV
// 抽象方法
- (void)loadCommand:(NSString *)command {}

@end

抽象出的遥控器父类

@interface Remote : NSObject

@property (nonatomic, strong) TV *tv;

- (void)setCommand:(NSString *)command;
@end


@implementation Remote

- (void)setCommand:(NSString *)command {
    [self.tv loadCommand:command];
}
@end

遥控器的实现

//这里遵循开闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭
@interface SubRemote : Remote

/**方向控制按钮*/
- (void)up;
- (void)down;
- (void)left;
- (void)right;

@end


@implementation SubRemote

- (void)up {
    [super setCommand:@"up"];
}

- (void)down {
    [super setCommand:@"down"];
}

- (void)left {
    [super setCommand:@"left"];
}

- (void)right {
    [super setCommand:@"right"];
}

@end

电视机的实现


@implementation TVXiaoMi

- (void)loadCommand:(NSString *)command {
    
    if ([command isEqualToString:@"up"]) {
        NSLog(@"您按的是XM:----%@",command);
    }
    else if ([command isEqualToString:@"down"]) {
        NSLog(@"您按的是XM:----%@",command);
    }
    else if ([command isEqualToString:@"left"]) {
        NSLog(@"您按的是XM:----%@",command);
    }
    else if ([command isEqualToString:@"right"]) {
        NSLog(@"您按的是XM:----%@",command);
    }
    else {
        NSLog(@"超出范围");
    }
}

@end

康佳


@implementation TVKJ
- (void)loadCommand:(NSString *)command {
    
    if ([command isEqualToString:@"up"]) {
        NSLog(@"您按的是KJ:----%@",command);
    }
    else if ([command isEqualToString:@"down"]) {
        NSLog(@"您按的是KJ:----%@",command);
    }
    else if ([command isEqualToString:@"left"]) {
        NSLog(@"您按的是KJ:----%@",command);
    }
    else if ([command isEqualToString:@"right"]) {
        NSLog(@"您按的是KJ:----%@",command);
    }
    else {
        NSLog(@"超出范围");
    }
}
@end

调用

 // 遥控器调用康佳电视
    SubRemote *subremote = [[SubRemote alloc] init];
    subremote.tv = [[TVKJ alloc] init];
    [subremote up];
    
    // 遥控器调用小米电视
    subremote.tv = [[TVXiaoMi alloc] init];
    [subremote down];
    [subremote right];

可以看到一个遥控器可以调用多个电视机，解耦实现

2.工厂模式

工厂模式分为三种简单工厂, 工厂方法, 抽象工厂。

简单工厂

简单工厂模式其实不是一个设计模式，反而比较像一种编程习惯。主要我们定义一个非常简单的类主要负责帮我们生产不同的产品。


这里写图片描述

demo

这里写图片描述

FruitsFactory工厂类

#import "Apple.h"
#import "Orange.h"
#import "Banana.h"

// 外界传进来的类型.
typedef NS_ENUM(NSInteger) {
    kApple,
    kOrange,
    kBanana
    
}FruitsType;

@interface FruitsFactory : NSObject

// 创建水果的工厂
+ (Fruits *)fruitsFactory:(FruitsType)type;

@end

#import "FruitsFactory.h"
@implementation FruitsFactory
+ (Fruits *)fruitsFactory:(FruitsType)type {
    // 创建对象
    Fruits *fruits = nil;
    
    switch (type) {
        case kApple:
            fruits = [[Apple alloc] init];
            break;
            
        case kOrange:
            fruits = [[Orange alloc] init];
            break;
            
        case kBanana:
            fruits = [[Banana alloc] init];
            break;
            
        default:
            break;
    }
    return fruits;
}
@end

水果父类


@interface Fruits : NSObject
- (void)sweet; /**< 甜的 */

- (void)poorTaste; /**< 不好吃 */

@end


@implementation Fruits
- (void)sweet {}

- (void)poorTaste {}
@end

子类的实现，这里就写苹果了，其他类似

//遵循了开闭原则
@interface Apple : Fruits

- (void)freshApple; /**< 新鲜的苹果 */

@end


@implementation Apple

- (void)sweet {
    NSLog(@"Apple 非常甜");
}
          
- (void)poorTaste {
    NSLog(@"Apple 不好吃");
}

- (void)freshApple {
    NSLog(@"Apple 新鲜的水果");
}

@end

viewcontroller的调用

- (void)viewDidLoad {
    [super viewDidLoad];
    // 创建出水果,在工厂方法里面
    Fruits *fruits = [FruitsFactory fruitsFactory:kApple];
    [fruits sweet];
    
    // 创建橘子
    Orange *orange = (Orange *)[FruitsFactory fruitsFactory:kOrange];
    [orange acidOrange];
    
}

工厂方法模式

定义创建对象的接口, 让子类觉得实例化哪一个类, 一个类要实例的时候, 被延迟到了子类里面进行实现。
他是对多个产品进行抽象

这里写图片描述

特点

每个工厂只操作自己对应的类，别的类他不管

demo

定义一个工厂超类和一个颜色超类，然后每个颜色的工厂类实现


这里写图片描述

这里只写红色的相关，蓝色那个和红色类似，就不写了
颜色工厂超类

// Generator 相当于是一个工厂

#import <Foundation/Foundation.h>
#import "RedView.h"
#import "BlueView.h"

@interface ColorViewGenerator : NSObject

- (ColorView *)colorViewWithFrame:(CGRect)frame;

@end

@implementation ColorViewGenerator

- (ColorView *)colorViewWithFrame:(CGRect)frame {
    return [[ColorView alloc] initWithFrame:frame];
}

@end

RedViewGenerator

@implementation RedViewGenerator

- (ColorView *)colorViewWithFrame:(CGRect)frame {
    return [[RedView alloc] initWithFrame:frame];
}
@end

颜色超类ColorView

@implementation ColorView

- (instancetype)initWithFrame:(CGRect)frame {
    if (self = [super initWithFrame:frame]) {
        [self setBackgroundColor:[UIColor grayColor]];
    }
    return self;
}

@end

红色类RedView

@implementation RedView

- (instancetype)initWithFrame:(CGRect)frame {
    if (self = [super initWithFrame:frame]) {
        
        self.backgroundColor = [UIColor redColor];
        
    }
    return self;
}

@end

调用方法：

 // 1.创建抽象的工厂类
    ColorViewGenerator *colorGen = [[BlueViewGenerator alloc] init];
    CGRect rect = CGRectMake(0, 0, 320, 600);
    ColorView *blueView = [colorGen colorViewWithFrame:rect];
    
    // 2. 添加进去
    [self.view addSubview:blueView];

抽象工厂

抽象工厂方法:对工厂抽象

定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

类型：创建类模式

这里写图片描述

demo

这里写图片描述

创建抽象工厂

#import "ColorViewFactory.h"

@implementation ColorViewFactory
// 生产颜色的view
+ (UIView *)colorView {
    return nil;
}

// 生产UIButton
+ (UIButton *)buttonView {
    return nil;
}
@end

抽象工厂的两个子类，只写red

#import "RedViewFactory.h"
#import "RedButton.h"
#import "RedSubView.h"

@implementation RedViewFactory

+ (UIView *)colorView {
    return [[RedSubView alloc] init];
}

+ (UIButton *)buttonView {
    return [RedButton buttonWithType:UIButtonTypeCustom];
}

@end

view和button就是普通的创建，重点在调用

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    UIView *red = [RedViewFactory colorView];
    UIButton *btn = [RedViewFactory buttonView];
    
    [self.view addSubview:btn];
    [self.view addSubview:red];
}

@end

抽象工厂模式与工厂方法模式的区别

抽象工厂

1.通过对象组合创建抽象产品
2.创建多个系列的产品
3.必须要修改父类的接口才能支持新的产品

工厂方法

1.通过类继承创建抽象产品
2.创建一种产品
3.子类化创建并重写工厂方法以创建新产品

最主要的区别点: 工厂方法: 多个产品抽象 抽象工厂:对工厂抽象

PS NSNumber

NSNumber是一个抽象工厂类

- (void)viewDidLoad {
    [super viewDidLoad];
    NSNumber *num = [[NSNumber alloc] init];
    
    NSNumber *intNum = [NSNumber numberWithInt:97];
    NSNumber *floatNum = [NSNumber numberWithFloat:1.0f];
    NSNumber *boolNum = [NSNumber numberWithBool:YES];
    
    NSLog(@"num = %@",[[num class] description]);
    
    NSLog(@"intNum = %@",[[intNum class] description]);
    NSLog(@"floatNum = %@",[[floatNum class] description]);
    NSLog(@"boolNum = %@",[[boolNum class] description]);
    
    NSLog(@"转化 = %c",[intNum charValue]);
}

结果


这里写图片描述

可以看到num是空的，因为他是一个抽象的超类

3.享元模式

定义：相同的数据就拿来共享
享元模式: 1.可共享享元对象. 2. 享元池

  1. 它主要是减少同一类型对象的大量创建，节约内存空间

  1. 在iOS开发中的多线程(线程池), UITableViewCell, UICollectionViewCell都是利用这个模式


    这里写图片描述

demo

做一个享元池，创建花朵

这里写图片描述

创建享元池工厂

#import "Flower.h"

typedef enum {
    kRedFlower,
    kBlueFlower,
    kYellowFlower,
    kTotalNumberFlower, // 总共的花的数量

}FlowerType;

@interface FlowerFactory : NSObject

// 享元池(缓存池), 存放享元对象
@property (nonatomic, strong) NSMutableDictionary *flowerPools;

// 创建花的工厂方法
- (Flower *)flowerViewWithType:(FlowerType)type;

// 打印详情类型
- (void)detailsType;

@end

#import "FlowerFactory.h"

@implementation FlowerFactory
- (Flower *)flowerViewWithType:(FlowerType)type {
    // 1.懒加载flowerPools. 初始化享元池
    if (self.flowerPools == nil) {
        self.flowerPools = [[NSMutableDictionary alloc] initWithCapacity:kTotalNumberFlower];
    }
    
    // 2. 去享元池里面取
    Flower *flower = [self.flowerPools objectForKey:[NSNumber numberWithInteger:type]];
    
    
    // 3. 如果没取到做判断
    if (flower == nil) {
        // 1. 创建花
        flower = [[Flower alloc] init];
        
        // 2.根据传进来的类型,去选择对应的类型
        switch (type) {
            case kRedFlower:
                flower.flowerColor = @"红色的花";
                flower.flowerName = @"红玫瑰";
                break;
                
            case kBlueFlower:
                flower.flowerColor = @"蓝色的花";
                flower.flowerName = @"蓝玫瑰";
                break;
                
            case kYellowFlower:
                flower.flowerColor = @"黄色的花";
                flower.flowerName = @"野菊花";
                break;
            default:
                break;
        }
        // 3.创建好的花, 添加到享元池
        [self.flowerPools setObject:flower forKey:[NSNumber numberWithInt:type]];
    }
    return flower;
}

- (void)detailsType {
    NSArray *array = [self.flowerPools allKeys];
    
    for (NSNumber *key in array) {
        Flower* flowre = self.flowerPools[key];
        NSLog(@"--keyAddress = %@---  key = %@,---颜色==%@", flowre, key,flowre.flowerColor);
    }
}

@end

flower类

@interface Flower : NSObject
@property (nonatomic, copy) NSString *flowerColor; // 花色
@property (nonatomic, copy) NSString *flowerName; // 花名
@end

调用

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    FlowerFactory *factory = [[FlowerFactory alloc] init];
    
//    Flower *flower = [factory flowerViewWithType:kYellowFlower];
    
    // 保存花的数组
    NSMutableArray *arrayFlowers = [[NSMutableArray alloc] init];
    
    for (int i = 0; i < 10; ++i) {
        // 设置堆积的类型数
        FlowerType flowerType = arc4random_uniform(kTotalNumberFlower);
        
        // 使用享元池来创建的
        Flower *flower = [factory flowerViewWithType:flowerType];
        

//        Flower *flower = [[Flower alloc] init];
        
        [arrayFlowers addObject:flower];
        
        // 打印详情
        [factory detailsType];
    }
    NSLog(@"flower = %lu", arrayFlowers.count);

}

结果


这里写图片描述

可以看到是公用的一个对象

优点

假如我把数量改的很大，分别采用享元池和不采用，查看内存


这里写图片描述

采用享元池如下


采用享元池

不采用享元池如下


不采用享元池

可以看到内存节省很多

注意

和UITableViewCell类似，要注意数据的复用

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,293评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,604评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,958评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,729评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,719评论 5赞 366
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,630评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,000评论 3赞 397
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,665评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,909评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,646评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,726评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,400评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,986评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,959评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,197评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 44,996评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,481评论 2赞 342

推荐阅读更多精彩内容

  • 设计模式汇总
    设计模式汇总 一、基础知识 1. 设计模式概述 定义：设计模式（Design Pattern）是一套被反复使用、多...
    MinoyJet阅读 3,897评论 1赞 15
  • 【结构型模式九】桥接模式(Bridge)
    1 场景问题# 1.1 发送提示消息## 考虑这样一个实际的业务功能：发送提示消息。基本上所有带业务流程处理的系统...
    七寸知架构阅读 4,954评论 5赞 63
  • Java中23种设计模式详解
    文章部分内容转载自：http://blog.csdn.net/zhangerqing 一、设计模式的分类 总体来说...
    j_cong阅读 2,055评论 0赞 20
  • 设计模式
    一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者...
    RamboLI阅读 742评论 0赞 1
  • 4.13
    祝自己生日快乐
    w小衍w阅读 990评论 8赞 2