Swift---22.协议

• 协议:

规定了用来实现某一特定任务或者功能的方法、属性，以及其他需要的东西.
- #####写法:
使用protocol关键字表明这是一个协议,在要遵守协议的类名后使用":协议名"来遵循协议,拥有父类的类型,父类放在最前面,用,隔开
protocol SomeProtocol { //协议定义 } class SomeClass { //类定义 } class SomeSubClass:SomeClass,SomeProtocol { //类定义 }
- 遵循了一个协议,就需要实现协议中的属性,方法,构造器
- ######协议属性:
Swift协议内,属性不确定是存储属性还是计算属性,只提供名称和类型,具体实现由其遵循的类来定义.同时,必须标明它是可读写,还是只读,通过{set get}标明可读写,通过{get}表示只读,同理,使用static,class表明属性为类属性
```
protocol SomeProtocol {
var anotherName:String{get}
static func getStr(a:String) ->String
}
class Person: SomeProtocol {
var anotherName: String {
return "name"
}
static var name :String {
return "name"
}
}

    Person.name
    var some = Person()
    some.anotherName
    ```
    - ######协议方法:

Swift协议内,不写方法的具体实现,只定义方法名称,方法参数类型,返回类型,具体实现由其遵循的类来定义.同理,使用static,class表明方法为类方法
protocol SomeProtocol { func getName()->String static func getStr(a:String) ->String } class Person: SomeProtocol { func getName() -> String { return "name" } static func getStr(a: String) -> String { return a+"!" } } Person.getStr(a: "aaa") var person = Person() person.getName()
- ######协议构造器:
Swift协议内,不写构造器的具体实现,只提供构造器参数,具体实现由其遵循的类来定义.
实现协议构造器时,需要使用required关键字来修饰,同时,添加了required关键字,就表示了该类的子类也拥有该构造器.
如果一个类的协议构造器跟父类的构造器相同,则必须同时加上required以及override关键字
protocol SomeProtocol { init(name:String) } class Person { var name:String init(name: String) { self.name = name } } class AnotherPerson:Person,SomeProtocol { required override init(name: String) { super.init(name: name) } } var person = AnotherPerson(name: "Allen") person.name
- ######协议作为类型
Swift中,协议可以作为参数,返回值,也可以作为属性类型,也可以作为Collection类型的元素类型
protocol SomeProtocol { init(name:String) } class Person { var name:String var someClass:SomeProtocol init(name: String,someClass:SomeProtocol) { self.name = name self.someClass = someClass } func getSomeClass()->(SomeProtocol) { return self.someClass } } class AnotherPerson:SomeProtocol{ required init(name: String) { print(name) } } var person = Person(name: "name", someClass: AnotherPerson(name: "protocol")) var someClass = person.getSomeClass() var array = [someClass]
- #####代理:
代理模式,一个类,委托某部分功能由代理实现.可以用来响应特定的动作，或者接收外部数据源提供的数据，而无需关心外部数据源的类型。
protocol SomeProtocol { func negative() func zero() func positive() } class Person { var someClass:SomeProtocol? func judgeInt(numbers:[Int]) { for number in numbers { switch number { case 0: someClass?.zero() case let number where number < 0: someClass?.negative() default: someClass?.positive() } } } } class AnotherPerson:SomeProtocol{ func negative() { print("-") } func zero() { print("0") } func positive() { print("+") } } var person = Person() person.judgeInt(numbers: [-1,0,11]) person.someClass = AnotherPerson() person.judgeInt(numbers: [-1,0,11,22,11])
- ######通过扩展使类满足协议
protocol SomeProtocol { subscript(index:Int)->Int { get } } extension Int:SomeProtocol { subscript(time:Int)->Int { return self*time } } 3[3]
- ######协议可以被另一个协议继承,这时遵循改子类协议的对象,必须同时实现子协议与父协议的方法
protocol SomeProtocol { subscript(index:Int)->Int { get } } protocol SubProtocol:SomeProtocol { subscript(index:String)->String { get } } extension Int:SubProtocol { internal subscript(index: String) -> String { return index + String(self) } subscript(time:Int)->Int { return self*time } } 3[3] 3["3"]
- ######类专属协议:
Swift中,可以通过在协议后添加:class来表明这个协议只能被类类型遵从,如果该协议有继承的父协议,使用,隔开,写在class后
protocol SomeProtocol { } protocol SubProtocol:class,SomeProtocol { } extension Int:SubProtocol { }
- ######合并协议:
在某些特定环境中,例如方法参数类型,我们有时候需要把多个协议要求合成,这是如果使用","号会报错,同时,如果使用(,)会将其变为元组,Swift中提供了&符号来合并协议.合并协议并不会生成新的协议,它只作用在某个特定的区域内
protocol SomeProtocol:class { } protocol AnotherProtocol:class { } func composition(class:SomeProtocol&AnotherProtocol){ }
- #####检查是否符合协议,使用"is","as?","as!"来判断,
- ######is:
用来检查实例是否符合某个协议，若符合则返回 true，否则返回 false。
- ######as?:
返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回 nil。
- ######as!:
将实例强制向下转换到某个协议类型，如果强转失败，会引发运行时错误
protocol SomeProtocol { } extension Int:SomeProtocol { } var array:[Any] = ["str",1] for item in array { if let object = item as? SomeProtocol { print("\(object)符合协议") }else { print("\(item)不符合协议") } }
- #####可选协议要求:
上面介绍的,不管是在协议中定义属性,方法,构造器,都是方法必须实现的.Swift中,我们可以定义协议中的某个要求为可选要求.在协议中使用optional作为前缀来定义可选要求.可选要求只能被Objective-C类或者@Objc的类遵循,所以必须在协议和要求前写上@objc
@objc protocol Name { @objc optional func printName() func printAnotherName() } //报错,因为String不是objc类型 //extension String:Name { // //} extension NSString:Name { func printAnotherName() { print("name") } }
- #####扩展协议:
协议可以通过扩展来为遵循协议的类型提供属性、方法以及下标的实现.实现后,每个遵循协议的类不需要再定义扩展中实现的某个要求
protocol Name { func printAnotherName() } extension Name { func printAnotherName() { print("name") } } class SomeClass:Name { } SomeClass().printAnotherName()