Swift3.0－协议（protocol）-蒲公英云

Swift3.0－协议（protocol）

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)
}