一起連帶前面幾篇Playground小結程式碼都轉到github上了，註釋寫了很多，主要方便自己以後可以翻翻看。Swift語法主要部分差不多就這些了。當然還有泛型、運算子過載、ARC、閉包之類的補充。

一、擴充套件（extension）

擴充套件 extension (類似OC中的分類, 但Swift中沒有名字), 即在沒有許可權獲取到原始程式碼的情況下, 為類增加新功能.

注意: 只要定義了擴充套件, 那麼該擴充套件對該類的例項都是可用的.

1. extension SomeType{  
2.     //新增到SomeType的新功能寫在這裡
3. }  

1.1擴充套件屬性(只能是計算屬性)

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. let jjLength = 1.m  // 1與m進行點運算, 表示1的Double值
8. let jjLength_km = 1.km  
9. println(10.km + 1.m)  

1.2

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

1.3擴充套件方法

下面是像Int中擴充套件

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

1.3.1 修改例項方法

通過擴充套件方法, 可以修改該例項self本身.但是方法前要加 mutating

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

1.4 擴充套件巢狀型別

即向已有的巢狀型別中新增新的巢狀型別. 還可以擴充套件下標(附屬指令碼)等.

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

可定義方法與屬性, 由具體的類去實現. 越來越像Java

Swift中的協議能被類, 列舉,結構體實現.

1. protocol SomeProtocol{  
2.     //協議內容
3. }  
4. class SomeClass : SomeProtocol{ //實現協議, 可實現多個協議
5. }  

2.1 協議中屬性/方法/突變方法的要求

2.1.1 屬性的要求

1. protocol AnotherProtocol1{  
2.     //class表示類成員(結構體/列舉中用static)
3.     class var property : Int { get set} //get, set 表示可讀可寫
4. }  
5. class AnotherClass1 : AnotherProtocol1{  
6.     class var property : Int {  //實現協議中的屬性
7.         get{  
8.             return10
9.         }  
10.         set{  
11.         }  
12.     }  
13. }  

2.1.2 方法要求

1. //不支援預設引數. 寫法上只是沒有方法的實現.
2. protocol AnotherProtocol2{  
3.     func myFunc() -> Int   //只宣告不實現
4. }  
5. class AnotherClass2 : AnotherProtocol2{  
6.     func myFunc() -> Int {  //實現方法
7.         return10
8.     }  
9. }  

2.1.3 突變方法要求

能在方法或函式內部改變例項型別的方法稱為突變方法. (mutating關鍵字)

在類中,可以不寫mutating, 但在結構體與列舉中國必須寫

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

2.2 協議型別.

協議也可以當做型別來使用. 這點和函式一樣.

1.可作為引數/返回值型別

2.可作為常量/變數/屬性的型別

3.可作為陣列/字典和其他元素型別

1. protocol MyRect{  
2.     func myLuckNumber() -> Int  
3. }  
4. class MyRectImp : MyRect{  
5.     func myLuckNumber() -> Int {  
6.         return10
7.     }  
8. }  
9. class Dice {  
10.     let sides :Int  
11.     var gener : MyRect    //作為型別
12.     init(sides:Int, gener:MyRect){  //作為引數
13.         self.sides = sides  
14.         self.gener = gener  
15.     }  
16. }  
17. var dice = Dice(sides: 6, gener: MyRectImp())  
18. dice.gener.myLuckNumber()   //返回10