欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

iOS面试题(二十九)设计模式

程序员文章站 2022-03-06 21:26:16
...

10.设计模式

iOS面试题(二十九)设计模式

 

  • 六大设计原则(设计模式所遵从的六大设计原则)
  • 责任链
  • 桥接
  • 适配器
  • 单例
  • 命令

六大设计原则(设计模式所遵从的六大设计原则)

iOS面试题(二十九)设计模式
设计原则

  1. 单一职责原则:通俗地讲就是一个类只做一件事
    CALayer:动画和视图的显示。
    UIView:只负责事件传递、事件响应。
     
  2. 开闭原则:对修改关闭,对扩展开放。
    要考虑到后续的扩展性,而不是在原有的基础上来回修改
     
  3. 接口隔离原则:使用多个专门的协议来做接口隔离、而不是一个庞大臃肿的协议
    UITableviewDelegate
    UITableViewDataSource
     
  4. 依赖倒置原则 :抽象不应该依赖于具体实现、具体实现可以依赖于抽象。
    调用接口感觉不到内部是如何操作的
     
  5. 里氏替换原则:父类可以被子类无缝替换,且原有的功能不受任何影响
    例如 KVO
     
  6. 迪米特法则
    一个对象应当对其他对象尽可能少的了解,实现高聚合、低耦合  
    模块和模块之前就少了千丝万缕的联系

二、责任链模式

iOS面试题(二十九)设计模式
要使用责任链模式来实现这种问题。
iOS面试题(二十九)设计模式
某一个类,它有一个成员变量,其类型是这个类本身。就是责任链模式。
主要思想:对象引用了同一类型的另一个对象,形成一条链。链中的每个对象实现了相同的方法,处理对链中第一个对象发起的同一请求,如果一个对象不知道如何处理,就把请求传给下一个响应器。

 

//BusinessObject.h
#import <Foundation/Foundation.h>

@class BusinessObject;
typedef void(^CompletionBlock)(BOOL handled);
typedef void(^ResultBlock)(BusinessObject *handler, BOOL handled);

@interface BusinessObject : NSObject

// 下一个响应者(响应链构成的关键)
@property (nonatomic, strong) BusinessObject *nextBusiness;
// 响应者的处理方法
- (void)handle:(ResultBlock)result;

// 各个业务在该方法当中做实际业务处理
- (void)handleBusiness:(CompletionBlock)completion;
@end
  
 //  BusinessObject.m

@implementation BusinessObject

// 责任链入口方法
- (void)handle:(ResultBlock)result
{
    CompletionBlock completion = ^(BOOL handled){
        // 当前业务处理掉了,上抛结果
        if (handled) {
            result(self, handled);
        }
        else{
            // 沿着责任链,指派给下一个业务处理
            if (self.nextBusiness) {
                [self.nextBusiness handle:result];
            }
            else{
                // 没有业务处理, 上抛
                result(nil, NO);
            }
        }
    };
    
    // 当前业务进行处理
    [self handleBusiness:completion];
}

- (void)handleBusiness:(CompletionBlock)completion
{
    /*
     业务逻辑处理
     如网络请求、本地照片查询等
     */
}

@end

桥接模式

iOS面试题(二十九)设计模式
列表和多套数据之间耦合的问题。


桥接模式的目的是把抽象层次结构从其实现中分离出来,使其能够独立变更。
类构成:

iOS面试题(二十九)设计模式

Class A 和ClassB都是抽象类。抽象类ClassA中一个成员变量是抽象类ClassB。
A1、A2、A3三个是ClassA的子类,B1、B2、B3是ClassB的三个子类。
ClassB中作为抽象类,只提供了默认的接口,并没有实现。B1、B2、B3是ClassB的三个子类,重写父类的接口方法,提供不同的实现,此时对于ClassB使用方来说,是感知到不使用了哪个实现。
ClassA中有一个handle处理方法,默认调用成员变量ClassB对象中的接口方法。A1、A2、A3三个是ClassA的子类,对于子类来说可以覆写父类的handle方法,做一些自定义的操作。

代码示例: ClassA

#import <Foundation/Foundation.h>
#import "BaseObjectB.h"
@interface BaseObjectA : NSObject
​
// 桥接模式的核心实现
@property (nonatomic, strong) BaseObjectB *objB;
​
// 获取数据
- (void)handle;
@end

 

#import "BaseObjectA.h"
​
@implementation BaseObjectA
​
/*
  组合方式:
  A1 --> B1、B2、B3         3种
  A2 --> B1、B2、B3         3种
  A3 --> B1、B2、B3         3种
*/
- (void)handle
{
  // override to subclass
  // 处理objB中的方法。
  [self.objB fetchData];
}
​
@end

ClassA的子类A1、A2、A3重写父类中handle方法。

 

#import "ObjectA1.h"
​
@implementation ObjectA1
​
- (void)handle
{
  // before 业务逻辑操作

  [super handle];

  // after 业务逻辑操作
}
@end

ClassB 实现

 

#import <Foundation/Foundation.h>
​
@interface BaseObjectB : NSObject
​
- (void)fetchData;
​
@end

 

#import "BaseObjectB.h"
​
@implementation BaseObjectB
// 默认逻辑实现
- (void)fetchData
{
  // override to subclass
}
@end

ClassB的子类进行具体的逻辑实现。

 

#import "ObjectB1.h"
​
@implementation ObjectB1
​
- (void)fetchData{
  // 具体的逻辑处理
}
@end

使用方代码实现

 

@interface BridgeDemo()
@property (nonatomic, strong) BaseObjectA *objA;
@end
​
@implementation BridgeDemo
​
/*
根据实际业务判断使用那套具体数据
A1 --> B1、B2、B3         3种
A2 --> B1、B2、B3         3种
A3 --> B1、B2、B3         3种
*/
- (void)fetch
{
  // 创建一个具体的ClassA
  _objA = [[ObjectA1 alloc] init];

  // 创建一个具体的ClassB
  BaseObjectB *b1 = [[ObjectB1 alloc] init];
  // 将一个具体的ClassB1 指定给抽象的ClassB
  _objA.objB = b1;

  // 获取数据
  [_objA handle];
}
@end

使用方中定义了ClassA对象,可以使用A1、A2、A3来创建不同的对象,获取不同的实现组合。BaseObjectB也可以有不同的实现组合。通过桥接模式不同的组合可以实现对象之间的解耦。

桥接模式的优点:

  • 分离抽象接口及其实现部分。

  • 桥接模式有时类似于多继承方案,但是多继承方案违背了类的单一职责原则(即一个类只有一个变化的原因),复用性比较差,而且多继承结构中类的个数非常庞大,桥接模式是比多继承方案更好的解决方法。

  • 桥接模式提高了系统的可扩充性,在两个变化维度中任意扩展一个维度,都不需要修改原有系统。

  • 实现细节对客户透明,可以对用户隐藏实现细节。

四、适配器

适配器模式(Adapter Pattern):将一个接口转换成客户希望的另一个接口,适配器模式使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。

本节主要学习对象适配器模式,简单的类结构如下。

iOS面试题(二十九)设计模式

适配对象中一个成员变量指向被适配对象。

示例代码:类Target是被适配对象,CoolTarget为适配对象。

Target类

 

#import <Foundation/Foundation.h>
​
@interface Target : NSObject
​
- (void)operation;
​
@end

 

#import "Target.h"
​
@implementation Target
​
- (void)operation
{
  // 原有的具体业务逻辑
}
​
@end

CoolTarget类:

 

#import "Target.h"
​
// 适配对象
@interface CoolTarget : NSObject
​
// 被适配对象
@property (nonatomic, strong) Target *target;
​
// 对原有方法包装
- (void)request;
​
@end

 

#import "CoolTarget.h"
​
@implementation CoolTarget
​
- (void)request
{
  // 额外处理

  [self.target operation];

  // 额外处理
}
​
@end

适配器优点:

  • 将目标类和适配者类解耦,通过引入一个适配器类来重用现有的适配者类,而无须修改原有代码。

  • 增加了类的透明性和复用性,将具体的实现封装在适配者类中,对于客户端类来说是透明的,而且提高了适配者的复用性。

  • 灵活性和扩展性都非常好,通过使用配置文件,可以很方便地更换适配器,也可以在不修改原有代码的基础上增加新的适配器类,完全符合“开闭原则”。

三、单例

单例模式(SingletonPattern):单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。

单例模式的要点有三个:一是某个类只能有一个实例;二是它必须自行创建这个实例;三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

 

示例代码:

 

@implementation Mooc
​
+ (id)sharedInstance
{
  // 静态局部变量
  static Mooc *instance = nil;

  // 通过dispatch_once方式 确保instance在多线程环境下只被创建一次
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
      // 创建实例
      instance = [[super allocWithZone:NULL] init];
  });
  return instance;
}
​
// 重写方法【必不可少】
+ (id)allocWithZone:(struct _NSZone *)zone{
  return [self sharedInstance];
}
​
// 重写方法【必不可少】
- (id)copyWithZone:(nullable NSZone *)zone{
  return self;
}
​
@end

注意点:为了防止使用者创建对象,需要从重写两个方法allocWithZonecopyWithZone:
另外instance = [[super allocWithZone:NULL] init];需要使用super方法调用防止在第一创建时循环调用。
 

四、命令模式

命令模式(CommandPattern):行为参数化的一种模式
(比如微博里面各个页面都会涉及到转发评论赞,如果我们把转发评论赞分别进行封装,以行为参数化的形式封装起来,当用户点击按钮的时候,再进行触发,降低系统的重合度。)

代码实例:一个命令对象和一个命令管理者。

Command

 

@class Command;
typedef void(^CommandCompletionCallBack)(Command* cmd);
​
@interface Command : NSObject
@property (nonatomic, copy) CommandCompletionCallBack completion; // 执行回调
​
- (void)execute; // 执行
- (void)cancel; // 取消
​
- (void)done; // 完成
​
@end

 

#import "Command.h"
#import "CommandManager.h"
@implementation Command
​
- (void)execute{

  //override to subclass;

  [self done];
}
​
- (void)cancel{

  self.completion = nil;
}
​
- (void)done
{
  dispatch_async(dispatch_get_main_queue(), ^{

      if (_completion) {
          _completion(self);
      }

      //释放
      self.completion = nil;
      // 在数组中移除
      [[CommandManager sharedInstance].arrayCommands removeObject:self];
  });
}
​
@end

CommandManager
可以用CommandManager保证任务的顺序执行,使用一个正在执行任务数组和一个等待执行任务数组,可以参考SDWebImage图片下载思路

 

#import <Foundation/Foundation.h>
#import "Command.h"
@interface CommandManager : NSObject
// 命令管理容器
@property (nonatomic, strong) NSMutableArray <Command*> *arrayCommands;
​
// 命令管理者以单例方式呈现
+ (instancetype)sharedInstance;
​
// 执行命令
+ (void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion;
​
// 取消命令
+ (void)cancelCommand:(Command *)cmd;
​
@end

 

#import "CommandManager.h"
​
@implementation CommandManager
​
// 命令管理者以单例方式呈现
+ (instancetype)sharedInstance
{
  static CommandManager *instance = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
      instance = [[super allocWithZone:NULL] init];
  });
  return instance;
}
​
// 【必不可少】
+ (id)allocWithZone:(struct _NSZone *)zone{
  return [self sharedInstance];
}
​
// 【必不可少】
- (id)copyWithZone:(nullable NSZone *)zone{
  return self;
}
​
// 初始化方法
- (id)init
{
  self = [super init];
  if (self) {
      // 初始化命令容器
      _arrayCommands = [NSMutableArray array];
  }
  return self;
}
​
+ (void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion
{
  if (cmd) {
      // 如果命令正在执行不做处理,否则添加并执行命令
      if (![self _isExecutingCommand:cmd]) {
          // 添加到命令容器当中
          [[[self sharedInstance] arrayCommands] addObject:cmd];
          // 设置命令执行完成的回调
          cmd.completion = completion;
          //执行命令
          [cmd execute];
      }
  }
}
​
// 取消命令
+ (void)cancelCommand:(Command *)cmd
{
  if (cmd) {
      // 从命令容器当中移除
      [[[self sharedInstance] arrayCommands] removeObject:cmd];
      // 取消命令执行
      [cmd cancel];
  }
}
​
// 判断当前命令是否正在执行
+ (BOOL)_isExecutingCommand:(Command *)cmd
{
  if (cmd) {
      NSArray *cmds = [[self sharedInstance] arrayCommands];
      for (Command *aCmd in cmds) {
          // 当前命令正在执行
          if (cmd == aCmd) {
              return YES;
          }
      }
  }
  return NO;
}
@end

命令模式的优点

  • 降低系统的重合度。

  • 新的命令可以很容易地加入到系统中。

  • 可以比较容易地设计一个命令队列和宏命令(组合命令)。

  • 可以方便地实现对请求的Undo和Redo。

怎么创建一个单例:

  • 通过dispatch_once方式 确保instance在多线程环境下只被创建一次的对象。
  • 为了防止使用者创建对象,需要从重写两个方法allocWithZonecopyWithZone:
  • 另外instance = [[super allocWithZone:NULL] init];需要使用super方法调用防止在第一创建时循环调用。

你知道什么设计原则?
桥接模式主体结构:

定义一个抽象父类Class A 和抽象父类ClassB。把抽象类ClassB作为抽象类ClassA中一个成员变量。
A1、A2、A3三个是ClassA的子类,B1、B2、B3是ClassB的三个子类。
然后就可以衍生出A1-B1   A1-B3  这样的关系。
两个父类其中持有一个,就构成了桥梁作用。

UI事件传递机制是怎样实现的?你对其中运用到的设计模式是怎样理解的?
设计模式角度是是责任链模式,一个类,它有一个成员变量,其类型是当前类的类型,就构成了责任链模式的基本结构。

相关标签: iOS面试题笔记