bt365官网-bt365体育在线投注-365体育在线

首页 >iOS开发

聊聊iOS中的多继承和多重代理

2018-11-05 17:16 编辑: 游星啊 分类:iOS开发 来源:Dariel

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

  1. 类B和C分别继承自A,B1和B2继承自B,C1和C2继承自C.现在我们需要在B1和C1中添加相同的方法,怎么去做?使用继承的话只能在类A中添加,但这样做的结果是基类A会越来越臃肿,最后变成上帝类God Class,维护起来会很困难.

  2. 在实现完某个代理后发现,我们还要在其他页面中获取数据.例如,IM消息接收之后要在多个地方做回调,比如显示消息内容页面,改变小红点,显示消息数.即一对多的模式,我们第一反应是用通知,但通知还是能少用就少用,用多了代码的可阅读性会大大降低.

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

1. 多继承

1. 实现过程

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

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

protocol Behavior {
    func run()
}
extension Behavior
 {
    func run() {
        print("Running...")
    }
}

struct Dog: Behavior {}

let myDog = Dog()
myDog.run() // Running...

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

下面举个例子.

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

// MARK: - 闪烁功能
protocol Blinkable {
    func blink()
}
extension Blinkable where SelfUIView
 {
    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 SelfUIView
 {
    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 SelfUIView
 {
    func roundCorners() {
        layer.cornerRadius = bounds.width * 0.1
        layer.masksToBounds = true
    }
}

extension UIView: Scalable, Blinkable, CornersRoundable {}

 cyanView.blink()
 cyanView.scale()
 cyanView.roundCorners()

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

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

请看下面代码

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. 定义协议

protocol MasterOrderDelegate: class {
    func toEat(_ food: String)
}

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

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

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

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

class masterOrderDelegateManager : MasterOrderDelegate {
    private let multiDelegate: NSHashTable = 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. 其余部分

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

作者:Dariel

链接:https://juejin.im/post/5bc943b85188255c31761c39

搜索bt365官网微信公众号:bt365官网
微信扫一扫
订阅每日移动开发及APP推广热点资讯
公众号:
bt365官网
我要投稿   收藏文章
上一篇:iOS--谈一谈模块化架构(附Demo)
我来说两句
发表评论
您还没有登录!请登录注册
所有评论(0

综合评论

相关帖子