Swift中扩展extension与协议protocol

原文：http://blog.csdn.net/xn4545945 

一、扩展（extension）

扩展 extension (类似OC中的分类, 但Swift中没有名字), 即在没有权限获取到原始代码的情况下, 为类增加新功能.

注意: 只要定义了扩展, 那么该扩展对该类的实例都是可用的.

[java] view plaincopy

1. extension SomeType{  
2.     //添加到SomeType的新功能写在这里  
3. }  

1.1扩展属性(只能是计算属性)

[java] view plaincopy

1. //扩展可以添加新计算属性, 但是不能添加存储属性(也不可以添加属性观察).  
2. extension Double{  //为API中的已有类型添加实例属性  
3.     var km : Double { return self * 1_000.0 }  
4.     var m : Double { return self }  
5.     var cm : Double { return self / 100.0 }  
6. }  
7.   
8. let jjLength = 1.m  // 1与m进行点运算, 表示1的Double值  
9. let jjLength_km = 1.km  
10. println(10.km + 1.m)  

1.2扩展构造器

[java] view plaincopy

1. //可以定制自己的构造器  
2. class MyClass{  
3.     var a : Int  
4.     init(){  
5.         a = 10  
6.     }  
7. }  
8.   
9. extension MyClass{  
10.     convenience init(var parm:Int){   //扩展构造器  
11.         self.init()  
12.         println("扩展构造器--->便利构造器, \(parm)")  
13.     }  
14. }  
15.   
16. var myClass = MyClass(parm: 9)  

1.3扩展方法

下面是像Int中扩展myIntFunc方法

[java] view plaincopy

1. extension Int{  
2.     func myIntFunc(){  
3.         println("值为\(self) , 哈哈哈哈!")  
4.     }  
5. }  
6.   
7. 1.myIntFunc()  

1.3.1 修改实例方法

通过扩展方法, 可以修改该实例self本身.但是方法前要加 mutating

[java] view plaincopy

1. extension Double{  
2.     mutating func myMoidfySelfValue{  
3.         self = self * self //修改self实例的值  
4.     }  
5. }  
6.   
7. var d = 2.0  
8. d.myMoidfySelfValue()  

1.4 扩展嵌套类型

即向已有的嵌套类型中添加新的嵌套类型. 还可以扩展下标(附属脚本)等.

[java] view plaincopy

1. extension Character {  
2.     enum Kind{   //嵌套了一个枚举类型  
3.         case Big  
4.         case Small  
5.     }  
6.     var k : Kind{  
7.         if(String(self).lowercaseString == "a"){  
8.             return Kind.Big  
9.         }else{  
10.             return Kind.Small  
11.         }  
12.     }  
13. }  
14. var ch : Character = "a"  
15. ch.k   //返回一个枚举值Kind.Big  

二、协议（protocol）

可定义方法与属性, 由具体的类去实现. 越来越像Java

Swift中的协议能被类, 枚举,结构体实现.

[java] view plaincopy

1. protocol SomeProtocol{  
2.     //协议内容  
3. }  
4.   
5. class SomeClass : SomeProtocol{ //实现协议, 可实现多个协议  
6.       
7. }  

2.1 协议中属性/方法/突变方法的要求

2.1.1 属性的要求

[java] view plaincopy

1. protocol AnotherProtocol1{  
2.     //class表示类成员(结构体/枚举中用static)  
3.     class var property : Int { get set} //get, set 表示可读可写  
4. }  
5.   
6. class AnotherClass1 : AnotherProtocol1{  
7.     class var property : Int {  //实现协议中的属性  
8.         get{  
9.             return 10  
10.         }  
11.         set{  
12.               
13.         }  
14.     }  
15. }  

2.1.2 方法要求

[java] view plaincopy

1. //不支持默认参数. 写法上只是没有方法的实现.  
2. protocol AnotherProtocol2{  
3.     func myFunc() -> Int   //只声明不实现  
4. }  
5.   
6. class AnotherClass2 : AnotherProtocol2{  
7.     func myFunc() -> Int {  //实现方法  
8.         return 10  
9.     }  
10. }  

2.1.3 突变方法要求

能在方法或函数内部改变实例类型的方法称为突变方法. (mutating关键字)

在类中,可以不写mutating, 但在结构体与枚举中国必须写

[java] view plaincopy

1. protocol Togg{  
2.     mutating func togg()  
3. }  
4.   
5. enum OnOffSwitch : Togg{  
6.     case Off , On  
7.       
8.     mutating func togg() { //改变实例的值  
9.         switch self{  
10.         case .Off:  
11.             self = On  
12.         case .On:  
13.             self = Off  
14.         }  
15.     }  
16. }  
17.   
18. var lightSwitch = OnOffSwitch.Off  
19. lightSwitch.togg()   //值变为On  

2.2 协议类型.

协议也可以当做类型来使用. 这点和函数一样.

1.可作为参数/返回值类型

2.可作为常量/变量/属性的类型

3.可作为数组/字典和其他元素类型

[java] view plaincopy

1. protocol MyRect{  
2.     func myLuckNumber() -> Int  
3. }  
4.   
5. class MyRectImp : MyRect{  
6.     func myLuckNumber() -> Int {  
7.         return 10  
8.     }  
9. }  
10.   
11. class Dice {  
12.     let sides :Int  
13.     var gener : MyRect    //作为类型  
14.     init(sides:Int, gener:MyRect){  //作为参数  
15.         self.sides = sides  
16.         self.gener = gener  
17.     }  
18. }  
19.   
20. var dice = Dice(sides: 6, gener: MyRectImp())  
21. dice.gener.myLuckNumber()   //返回10