Swift入门教程17-协议(二)

原创Blog，转载请注明出处

http://blog.csdn.net/hello_hwc

本文主要补充上一篇文章中未提及的协议的功能

一、扩展中的协议

1、通过扩展来遵循协议

protocol TextProtocol {
	func asString() -> String
}
class ID{
	var ID:Int	 = 0
}
extension ID:TextProtocol{
	func asString()->String{
		return String(ID)
	}
}

2、通过扩展补充协议声明

class ID{
	var ID:Int = 0
	func asString()->String{
		return String(ID)
	}
}
extension ID:TextProtocol

二、协议类型可以保存在集合中

由于协议本身是一种类型，所以可以保存在集合类型中。

protocol HwcProtocol{
	func logDescription()
}
class Obj1:HwcProtocol{
	func logDescription(){
		println("From obj1")
	}
}
class Obj2:HwcProtocol{
	func logDescription(){
		println("From obj2")
	}
}
class Obj3:HwcProtocol{
	func logDescription(){
		println("From obj3")
	}
}
var obj1 = Obj1()
var obj2 = Obj2()
var obj3 = Obj3()
let things: [HwcProtocol] = [obj1,obj2,obj3]
for thing in things {
	println(thing.logDescription())
}

数组中的每个元素都是协议的遵循着，所以都会实现协议中的方法。

就可以这样调用

三、协议可以继承

与类相似，用冒号表示继承，多个继承用逗号隔开

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 协议定义
}

四、类专属协议

通过在第一个协议继承列表中添加class来表示协议只能被类实现

protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
// class-only protocol definition goes here
}

五、协议合成

注意：协议合成并不会生成一个新的协议，在超出生命周期后会失效

protocol Named {
	var name: String { get }
}
protocol Aged {
	var age: Int { get }
}
struct Person: Named, Aged {
	var name: String
	var age: Int
}
//这里protocol<Named, Aged>表示同时遵循两个协议的类型
func wishHappyBirthday(celebrator: protocol<Named, Aged>) {
	println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
}
let birthdayPerson = Person(name: "Malcolm", age: 21)
wishHappyBirthday(birthdayPerson)
// 输出 "Happy birthday Malcolm - you're 21

六、协议的一致性

三点规则

1、用is来判断实例是否遵循了某个协议

2、用as?来进行可选转换

3、用as来进行强制转换

七、可选协议的规定

用@optional 来声明某个方法或者属性可选实现

注意：可选协议只能在@objc前缀的协议中生效

@objc表示协议是可选的，并且表示可以暴露给Objective C，并且协议只对类有效

例如

@objc protocol CounterDataSource {
	optional func incrementForCount(count: Int) -> Int
	optional var fixedIncrement: Int { get }
}
@objc class Counter {
	var count = 0
	var dataSource: CounterDataSource?
	func increment() {
		if let amount = dataSource?.incrementForCount?(count) {
			count += amount
	} else if let amount = dataSource?.fixedIncrement? {
			count += amount
	}
	init(count:Int){
		self.count = count
	}
	}
}

声明一个计数器协议，然后功能类Counter完成技术，Counter有一个属性count用来返回当前的计数。

它保存了保存了这个协议类型作为接口，然后在increase方法中检查协议实现者实现了协议中哪个增加计数的方式，对应增加计数器。

然后，用户在使用Counter类的时候，选择性实现那种方法

class HwcTest:CounterDataSource{
	var counter:Counter
	init(counter:Counter){
		self.counter = counter;
		self.counter.dataSource = self;
	}
	var fixedIncrement = 10
	func hwcPrint(){
		for i in 1...10{
			println(counter.count)
			counter.increment()
		}
	}
}

同样，也可以使用

class HwcTest:CounterDataSource{
	var counter:Counter
	init(counter:Counter){
		self.counter = counter;
		self.counter.dataSource = self;
	}
	func incrementForCount(count: Int)->Int{
		return count+1
	}
	func hwcPrint(){
		for i in 1...10{
			println(counter.count)
			counter.increment()
		}
	}
}