Swift3.0－协议（protocol）

浅浅的花香味﹌ 2023-10-17 10:13 18阅读 0赞

Swift3.0－ 协议（protocol）代理，委托

/*
     * Protocol协议 （接口Interface或者纯虚函数）
      协议用于统一方法和属性的名称，而不实现任何功能（使用代理设计模式）
      协议能够被类、枚举、结构体实现，满足协议要求的类、枚举被称为协议实现者
      实现者需要提供协议指定的成员，如属性、操作符、方法和下表等
     */
    protocol SomeProtocol{
        var musBeSttable:Int{get set}
        static func someType()
    }
    
    protocol FirstProtocol{
    }
    
    protocol SecondProtocol{
    }
    
    //实现协议时，在类、结构体、枚举后面加上协议名称，多个协议之间以“，”隔开
    struct SomeStructs:FirstProtocol,SecondProtocol {
    }
    
    class Father{
    }
    
    //某个类含有父类的同时并实现了协议，应当将父类放在所有协议之前
    class Son:Father,SomeProtocol{
        internal var musBeSttable: Int = 0
        internal static func someType() {
            print("son")
        }
    }
    var son = Son()
    Son.someType()
    
    protocol Togglable{
        mutating func toggle()
    }
    enum OnOffSwitch:Togglable {
        case Off,On
        mutating func toggle() {
            switch self {
            case .Off:
                self = .On
            case .On:
                self = .Off
            }
        }
    }
    var lightSwitch = OnOffSwitch.Off
    lightSwitch.toggle()
    
    //使用协议构造函数
    protocol AProtocol{
        init(someParameter:Int)
    }
    class SomeClass: AProtocol {
        required init(someParameter:Int) {
        }
    }
    
    /*
     * 委托、代理 （一种设计模式）
      委托/代理是一种设计模式，允许类或者结构体将一些他们需要负责的功能交由（委托）给其他类型
      委托模式可以用来响应特定的动作或者接受外部数据源提供的数据，而无需知道外部数据源的类型
     */
    
    
    /*
     * 协议合成protocol<,,...>
     */
    protocol Named {
        var name:String{get}
    }
    protocol Aged {
        var age:Int{get}
    }
    struct Person:Named,Aged {
        var name: String
        var age:Int
    }
    func wishHappayBirthday(celebrator:Named & Aged){
        print("协议合成:\nHappy birthday to \(celebrator.name) - you are \(celebrator.age)")
    }
    let person = Person(name:"John",age:16)
    wishHappayBirthday(celebrator: person)
    
    
    /*
     * 检验协议一致性
      is操作符检查实例是否实现了某个协议
      as?返回一个可选值，当实例实现协议时，返回该协议类型，否则返回nil
      as用以强制向下转换类型
     */
    //@objc表示协议是可选的，!!!且只对类有效
    @objc protocol HasArea{
        var area:Double {get}
    }
    class Circle:HasArea {
        let pi = 3.1415927
        var radius:Double
        var area:Double{//计算属性
            return pi * radius * radius
        }
        init(radius:Double) {
            self.radius = radius
        }
    }
    class Country:HasArea{
        var area: Double //存储属性
        init(area:Double) {
            self.area = area
        }
    }
    class Animal{
        var legs:Int
        init(legs:Int) {
            self.legs = legs
        }
    }
    let objects:[AnyObject] = [Circle(radius:2.0),
                               Country(area:243_610),
                               Animal(legs:80)
                                ]
    for object in objects{
        if let objWithA = object as? HasArea{
            print("obj is \(objWithA.area)")
        }
        else{
            print("some thing does not have area")
        }
    }
    
    
    /*
     * 可选协议
      协议中使用optional关键字定义可选成员
      可选协议只能在含有@objc前缀的协议中生效；且@objc的协议只能被类实现
     */
    print("可选协议")
    @objc protocol CountDataSource{
        @objc optional func increForCount(count:Int) -> Int
        @objc optional var fixedIncrement:Int{get}
    }
    class Counter{
        var count = 0
        var dataSource:CountDataSource?
        func increment() {
            if let amount = dataSource?.increForCount?(count:count){
                count += amount
            }else if let amount = dataSource?.fixedIncrement{
                count += amount
            }
        }
    }
    class TreeSource: CountDataSource {
        let fixedIncrement = 3
    }
    var counter = Counter()
    counter.dataSource = TreeSource()
    for _ in 1...4{
        counter.increment()
        print(counter.count)
    }