20、面向协议编程

2018-07-03 | 阅读：

面向协议编程

一、面向协议

面向协议编程（Protocol Oriented Programming，简称POP）
是Swift的一种编程范式， Apple于2015年WWDC提出
在Swift的标准库中，能见到大量POP的影子

同时，Swift也是一门面向对象的编程语言（Object Oriented Programming，简称OOP）
在Swift开发中，OOP和POP是相辅相成的，任何一方并不能取代另一方

POP能弥补OOP一些设计上的不足

二、回顾OOP

OOP的三大特性：封装、继承、多态
继承的经典使用场合
当多个类（比如A、B、C类）具有很多共性时，可以将这些共性抽取到一个父类中（比如D类），最后A、B、C类继承D类

三、OOP的不足

但有些问题，使用OOP并不能很好解决，比如
如何将 BVC、DVC 的公共方法 run 抽取出来？

class BVC: UIViewController {
    func run() {
        print("run")
    }
}

class DVC: UITableViewController {
    func run() {
        print("run")
    }
}

基于OOP想到的一些解决方案？

将run方法放到另一个对象A中，然后BVC、DVC拥有对象A属性
多了一些额外的依赖关系
将run方法增加到UIViewController分类中
UIViewController会越来越臃肿，而且会影响它的其他所有子类
将run方法抽取到新的父类，采用多继承？（C++支持多继承）
会增加程序设计复杂度，产生菱形继承等问题，需要开发者额外解决

四、POP的解决方案

protocol Runnable {
    func run()
}
extension Runnable {
    func run() {
        print("run")
    }
}
class BVC: UIViewController, Runnable {}
class DVC: UITableViewController, Runnable {}

又比如下面这种情况：

POP的注意点

优先考虑创建协议，而不是父类（基类）
优先考虑值类型（struct、enum），而不是引用类型（class）
巧用协议的扩展功能
不要为了面向协议而使用协议

// 一、面向协议编程
class LCLifeObj20 {}
class LCAnimal20: LCLifeObj20,LCRunnal20 {
    func run() -> Void {
        print("running")
    }
}
class LCPerson20: LCLifeObj20 {}
class LCTeacher20: LCPerson20,LCRunnal20 {
    func run() -> Void {
        print("running")
    }
}
protocol LCRunnal20 {}
extension LCRunnal20 {
    func run2() -> Void {
        print("run2")
    }
}
func poProgramming1() -> Void {

    //分别实现
    LCAnimal20().run()
    LCTeacher20().run()
    
    //通过扩展协议实现
    LCAnimal20().run2()
    LCTeacher20().run2()
}

利用扩展添加前缀效果

//2、扩展方法和计算属性
extension String {
    
    //扩展方法,为了防止与系统方法重名加个前缀
    func lc_numberCount() -> Int{
        var count = 0
        for c in self where ("0"..."9").contains(c) {
            count += 1
        }
        return count
    }

    //扩展：计算属性
    var lc_numCount:Int{
        var count = 0
        for c in self where ("0"..."9").contains(c) {
            count += 1
        }
        return count
    }
}

//3、优雅的添加前缀
extension String {
    
    //扩展：前缀类
    struct LC201 {
        let string:String
        init(_ string:String) {
            self.string = string
        }
        var numCount:Int{
            var count = 0
            for c in string where ("0"..."9").contains(c) {
                count += 1
            }
            return count
        }
    }
    
    //增加一个前缀类计算属性
    var lc201:LC201{LC201(self)}
}


//4、优雅的添加前缀（通用）
struct LZ201<Base> {
    let base : Base
    init(_ base:Base) {
        self.base = base
    }
}


//String添加numCount
extension String {
    var lz201:LZ201<String>{LZ201(self)}
}
extension LZ201 where Base == String {
    var numCount:Int{
        var count = 0
        for c in base where ("0"..."9").contains(c) {
            count += 1
        }
        return count
    }
}


//Array添加numCount计算属性
extension Array {
    var lz201:LZ201<Array>{LZ201(self)}
}
extension LZ201 where Base == Array<String> {
    var numCount:Int{
        var count = 0
        for item in base where Int(item) != nil {
            count += 1
        }
        return count
    }
    
}


func poProgramming2() -> Void {
    
    //1、通过方法
    do{
        print("-----1-----")
        
        let str = "1234test1234"
        func numberCount(_ str:String) -> Int{
            var count = 0
            for c in str where ("0"..."9").contains(c) {
                count += 1
            }
            return count
        }
        print(numberCount(str))//8
    }
    
    
    //2、扩展方法和计算属性
    do{
        print("-----2-----")
        let str = "1234test1234"
        print(str.lc_numberCount())//8
        print(str.lc_numCount)//8
    }
    
    
    //3、优雅的添加前缀
    do{
        print("-----3-----")
        let str = "1234test1234"
        print(str.lc201.numCount)
    }
    
    
    //4、优雅的添加前缀（通用）
    do{
        print("-----4-----")
        let str = "1234test1234"
        print(str.lz201.numCount)
        
        let arr = ["12","34","hello","02"]
        print(arr.lz201.numCount)
    }
}

利用协议添加前缀效果

//前缀类
struct LC202<Base> {
    let base:Base
    init(_ base:Base){
        self.base = base
    }
}

//定义一个协议，扩展一个前缀类属性
protocol LCCompatible {}
extension LCCompatible {
    var lc202:LC202<Self>{
        set{}
        get{ LC202(self) }
    }
    
    static var lc202:LC202<Self>.Type{
        set{}
        get{ LC202<Self>.self }
    }
}


extension String : LCCompatible{}
extension NSString : LCCompatible{}
extension LC202 where Base : ExpressibleByStringLiteral {
    var numberCount : Int {
        var count = 0
        for c in base as! String where ("0"..."9").contains(c){
            count += 1
        }
        return count
    }
    
    static var numberCount : Int {
        print("String numberCount")
        return 999
    }
}


class LCPerson202 {}
class LCStudent202: LCPerson202 {}


extension LCPerson202 : LCCompatible{}
extension LC202 where Base : LCPerson202{
    func run() -> Void {
        print("run")
    }
    
    static func run()->Void{
        print("static run")
    }
}


//一、利用协议实现前缀效果
func poProgramming3() -> Void {
    let s1 = "1234test1234"
    let s2:NSString = "1234test1234"
    let s3:NSMutableString = "1234test1234"
    print( s1.lc202.numberCount )
    print( s2.lc202.numberCount )
    print( s3.lc202.numberCount )

    print(String.lc202.numberCount)
    print(NSString.lc202.numberCount)
    print(NSMutableString.lc202.numberCount)

    
    LCPerson202().lc202.run()
    LCPerson202.lc202.run()
    
    LCStudent202().lc202.run()
    LCStudent202.lc202.run()
}

利用协议实现类型判断

//二、利用协议实现类型判断
protocol ArrayType {}
extension Array: ArrayType {}
extension NSArray: ArrayType {}

func poProgramming4() -> Void {
    
    //1、判断是否是Array类型
    do{
        print("-----1-----")
        func isArray(_ value: Any) -> Bool { value is [Any] }
        print( isArray( [1, 2] )            )//true
        print( isArray( ["1", 2] )          )//true
        print( isArray( NSArray() )         )//true
        print( isArray( NSMutableArray() )  )//true
    }
    
    
    //2、判断是否是Array.Type类型
    do{
        print("-----3-----")
        func isArrayType(_ type: Any.Type) -> Bool { type is [Any].Type }
        print( isArrayType([Int].self)          )//false
        print( isArrayType([Any].self)          )//true
        print( isArrayType(NSArray.self)        )//false
        print( isArrayType(NSMutableArray.self) )//false
    }

    
    //3、判断是否是Array.Type类型
    do{
        print("-----3-----")
        func isArrayType(_ type: Any.Type) -> Bool { type is ArrayType.Type }
        print( isArrayType([Int].self)          )//true
        print( isArrayType([Any].self)          )//true
        print( isArrayType(NSArray.self)        )//true
        print( isArrayType(NSMutableArray.self) )//true
    }
}

行者常至，为者常成！

JHHK