正文

谈谈iOS中的多继承与多重代理

︶ㄣ速达网 メ
米米素材网V管理员 / 阅读
0711

这篇文章主要给大家介绍了关于iOS中多继承与多重代理的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

前言

多继承和多重代理在swift的语言层面上是不支持的,但我们有时会遇到这样的问题:

  • 类b和c分别继承自a,b1和b2继承自b,c1和c2继承自c.现在我们需要在b1和c1中添加相同的方法,怎么去做?使用继承的话只能在类a中添加,但这样做的结果是基类a会越来越臃肿,最后变成上帝类god class,维护起来会很困难.
  • 在实现完某个代理后发现,我们还要在其他页面中获取数据.例如,im消息接收之后要在多个地方做回调,比如显示消息内容页面,改变小红点,显示消息数.即一对多的模式,我们第一反应是用通知,但通知还是能少用就少用,用多了代码的可阅读性会大大降低.

面对第一种情况,最好的解决方法是,b1和c1的公共方法专门封装到一个地方,需要的时候就调用一下,多继承就是一个最好的解决方案.

1. 多继承

1. 实现过程

swift中的类可以遵守多个协议,但是只可以继承一个类,而值类型(结构体和枚举)只能遵守单个或多个协议,不能做继承操作.

多继承的实现:协议的方法可以在该协议的extension中实现

?
1
2
3
4
5
6
7
8
9
10
11
12
13
protocol behavior {
 func run()
}
extension behavior {
 func run() {
  print("running...")
 }
}
 
struct dog: behavior {}
 
let mydog = dog()
mydog.run() // running...

无论是结构体还是类还是枚举都可以遵守多个协议,所以要实现多继承,无非就是多遵守几个协议的问题.

下面举个例子.

2. 通过多继承为uiview扩展方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// mark: - 闪烁功能
protocol blinkable {
 func blink()
}
extension blinkable where self: uiview {
 func blink() {
  alpha = 1
  
  uiview.animate(
   withduration: 0.5,
   delay: 0.25,
   options: [.repeat, .autoreverse],
   animations: {
    self.alpha = 0
  })
 }
}
 
// mark: - 放大和缩小
protocol scalable {
 func scale()
}
extension scalable where self: uiview {
 func scale() {
  transform = .identity
  
  uiview.animate(
   withduration: 0.5,
   delay: 0.25,
   options: [.repeat, .autoreverse],
   animations: {
    self.transform = cgaffinetransform(scalex: 1.5, y: 1.5)
  })
 }
}
 
// mark: - 添加圆角
protocol cornersroundable {
 func roundcorners()
}
extension cornersroundable where self: uiview {
 func roundcorners() {
  layer.cornerradius = bounds.width * 0.1
  layer.maskstobounds = true
 }
}
 
extension uiview: scalable, blinkable, cornersroundable {}
 
 cyanview.blink()
 cyanview.scale()
 cyanview.roundcorners()

谈谈iOS中的多继承与多重代理

这样,如果我们自定义了其他view,只需要放大和缩小效果,遵守scalable协议就可以啦!

3. 多继承钻石问题(diamond problem),及解决办法

请看下面代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protocol protocola {
  func method()
}
 
extension protocola {
  func method() {
    print("method from protocola")
  }
}
 
protocol protocolb {
  func method()
}
 
extension protocolb {
  func method() {
    print("method from protocolb")
  }
}
 
class myclass: protocola, protocolb {}

此时protocola和protocolb都有一个默认的实现方法method(),由于编译器不知道继承过来的method()方法是哪个,就会报错.

钻石问题diamond problem,当某一个类或值类型在继承图谱中有多条路径时就会发生.

解决方法:

1. 在目标值类型或类中重写那个发生冲突的方法method().

2. 直接修改协议中重复的方法.

文章开头我们提到的问题2,我们可以试着用多重代理去解决这个问题.

2. 多重代理

1. 多重代理的实现过程

我们以一个代理的经典问题来表述:

主人叫宠物们去吃饭,吃这个动作作为一个协议,我们要做到统一管理.

1. 定义协议

?
1
2
3
protocol masterorderdelegate: class {
  func toeat(_ food: string)
}

2. 定义一个类: 用来管理遵守协议的类

这边用了nshashtable来存储遵守协议的类,nshashtable和nsset类似,但又有所不同,总的来说有这几个特点:

1. nshashtable中的元素可以通过hashable协议来判断是否相等.

2. nshashtable中的元素如果是弱引用,对象销毁后会被移除,可以避免循环引用.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class masterorderdelegatemanager : masterorderdelegate {
  private let multidelegate: nshashtable<anyobject> = nshashtable.weakobjects()
 
  init(_ delegates: [masterorderdelegate]) {
    delegates.foreach(multidelegate.add)
  }
  
  // 协议中的方法,可以有多个
  func toeat(_ food: string) {
    invoke { $0.toeat(food) }
  }
  
  // 添加遵守协议的类
  func add(_ delegate: masterorderdelegate) {
    multidelegate.add(delegate)
  }
  
  // 删除指定遵守协议的类
  func remove(_ delegatetoremove: masterorderdelegate) {
    invoke {
      if $0 === delegatetoremove as anyobject {
        multidelegate.remove($0)
      }
    }
  }
  
  // 删除所有遵守协议的类
  func removeall() {
    multidelegate.removeallobjects()
  }
 
  // 遍历所有遵守协议的类
  private func invoke(_ invocation: (masterorderdelegate) -> void) {
    for delegate in multidelegate.allobjects.reversed() {
      invocation(delegate as! masterorderdelegate)
    }
  }
}

3. 其余部分

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class master {
  weak var delegate: masterorderdelegate?
  func ordertoeat() {
    delegate?.toeat("meat")
  }
}
 
class dog {}
extension dog: masterorderdelegate {
  func toeat(_ food: string) {
    print("\(type(of: self)) is eating \(food)")
  }
}
 
class cat {}
extension cat: masterorderdelegate {
  func toeat(_ food: string) {
    print("\(type(of: self)) is eating \(food)")
  }
}
 
let cat = cat()
let dog = dog()
let cat1 = cat()
 
let master = master()
// master的delegate是弱引用,所以不能直接赋值
let delegate = masterorderdelegatemanager([cat, dog])
// 添加遵守该协议的类
delegate.add(cat1)
// 删除遵守该协议的类
delegate.remove(dog)
 
master.delegate = delegate
master.ordertoeat()
 
// 输出
// cat is eating meat
// cat is eating meat

设置masterorderdelegatemanager的好处是,可以通过一个数组来管理多重代理.

更多ios相关知识点欢迎关注我的github: swifttips

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对米米素材网的支持。

原文链接：https://www.jianshu.com/p/86a7948bf701