Swift2.0（16）分類與協議

• 擴展（分類）

類似于Objective-C中的分類功能

     即：在現有的一個類型（類類型、結構體、枚舉）的基礎上添加功能（方法）

     這個現有的類，可以是自定義的，也可以是其他框架中的（甚至沒有源代碼的）

     提供了一定的“逆向開發”的能力

格式：

     extension 現有類型 {

          //添加的功能

     }

可添加的功能：

     a. 添加行為屬性、類行為屬性（靜態行為屬性）、靜態存儲屬性

     b. 添加各種方法：實例方法、類方法（靜態方法）、便捷構造方法、下標方法等

     c. 添加新的嵌套類型

     d. 添加需要遵循的協議

     其中：類屬性、類方法是類類型的，二靜態   

不能添加的功能：

     a. 對象的存儲屬性（類存儲屬性(靜態屬性)可以）

     b. 不能重寫方法，但可以重載

     c. 不能添加重名行為屬性

意義：

     逆向開發

     復雜類型分模塊開發

     ...

如結構體：

    extension Double {
        static var pi1 = 3.14  //靜態存儲屬性
        var pi2:Double { //行為方法
            return 3.14
        }
        static var pi3:Double { //靜態行為屬性
            return 3.14
        }
        func print1() { //實例方法
            print(self.pi2)
        }
        static func print2() { //靜態方法
            print(self.pi3)
        }
    }
    var d1:Double = Double()
    print(Double.pi1)
    print(d1.pi2)
    print(Double.pi3)
    d1.print1()

    Double.print2()

如類類型：

    class A {
        var names:[AnyObject] = [AnyObject]()
    }
    extension A {
        static var pi1 = 3.14 //靜態存儲屬性
        var pi2:Double { //行為方法
            return 3.14
        }
        class var pi3:Double { //類行為屬性
            return 3.14
        }
        func print1() { //實例方法
            print(self.pi2)
        }
        class func print2() { //類方法
            print(self.pi3)
        }
        //便捷構造方法
        convenience init(value:AnyObject, number:Int) {
            self.init()
            for var i=0; i<number; i++ {
                self.names.append(value)
            }
        }
        //下標腳本方法
        subscript(index:Int)->AnyObject {
            get {
                return self.names[index]
            }
            set {
                self.names[index] = newValue
            }
        }
    }
    var a1:A = A(value: "hello", number: 5)
    for var i=0;i<5;i++ {
        print(a1[i])
    }
    print(A.pi1)
    print(a1.pi2)
    print(A.pi3)
    a1.print1()

    A.print2()

• 協議

協議規定了用來實現某些特定功能所需要的方法及屬性

     類類型、結構體、枚舉都可以遵循協議，即獲得協議中規定接口并實現這些接口

     即：面向接口編程

協議定義格式：

     protocol 協議名稱 { 協議體 }

     protocol 協議名稱:協議1, 協議2  { 協議體 }

     協議還可以繼承其他協議，且可以使多繼承的

類類型特定協議格式：

     @objc protocol 協議名稱 { 協議體 }

     protocol 協議名稱: class { 協議體 }

     遵循協議的類型在實現的屬性和方法前前需要 @objc 修飾

類型遵循協議：

     class 類名 : 協議名1, 協議名2 { }

     struct/enum 名字: 協議名1, 協議名2 { }

     類型可以遵循多個協議（只能有一個父類）

協議中的方法：

     協議中添加一系列相關方法的接口，并在遵循類型中給出實現

     可以是對象方法，也可以是類方法（用static修飾）

     在@objc修飾的協議中，可以使用optional修飾方法/屬性

          在遵循類型中可以選擇是否給出實現，否則必須實現

     如：

    @objc protocol AProtocol {
        func sayHello()->String
        static func sayHello()->String

    }

    class A : AProtocol {
        @objc func sayHello()->String {
            return "hello"
        }
        @objc class func sayHello()->String {
            return "HELLO"
        }

    }

協議中的屬性：

     只能用var描述屬性，遵循協議的類型實現屬性時不能修改類型及標示符

     協議中聲明的屬性不能賦初值

     可以是 實例屬性 也可以是 類屬性（用static修飾）

     屬性后{get} 表示 該屬性在實現時可以是var也可以是let

     屬性后{get set } 表示 該屬性在顯示時只能是var不能是let

     如：

    protocol CarProtocol {
        var brandName:String { get set }    //品牌
        var modelName:String { get set }    //車型

        var price:Double { get set }        //價格

    }

    protocol HouseProtocol {
        var houseName:String { get set }    //小區名
        var houseSize:Double { get set }    //平米大小
        var houseUnitPrice:Double { get set } //樓房單價

    }

    protocol MarryProtocol: CarProtocol, HouseProtocol {
        static var isMarrayed:Bool { get set }
        var marrayYear:Int { get }

    }

    class Person:MarryProtocol {
        //CarProtocol
        var brandName:String = ""
        var modelName:String = ""

        var price:Double = 0.0

        //HouseProtocol
        var houseName:String = ""
        var houseSize:Double = 0.0

        var houseUnitPrice:Double = 0.0

        //MarrayProtocol
        static var isMarrayed:Bool = false
        var marrayYear:Int {
            get {
                return 1
            }
        }

    }

協議中聲明構造方法

     在協議中可以聲明構造方法（包括便捷構造、可失敗構造）

     遵循協議的類，在實現構造方法時，需要使用 required 關鍵字修飾

          其意義：該類的子類，需要重寫這個協議聲明的構造方法

          遵循協議的類，使用final修飾時，可以不適用required修飾構造方法

協議作為類型

     protocol<協議1,協議2,...>

     如：

    protocol AProtocol {
        static var name:String { get set }
    }
    protocol BProtocol {
        var age:Int { get set }
    }
    struct AStruct : AProtocol, BProtocol {
        static var name:String = "AAA"
        var age:Int = 111
    }
    struct BStruct : AProtocol, BProtocol {
        static var name:String = "BBB"
        var age:Int = 222
    }
    var p1:protocol<AProtocol, BProtocol> = AStruct()

    var p2:protocol<AProtocol, BProtocol> = BStruct()

協議的應用場合：

     一定程度上實現了多繼承的功能

     常見的設計模式中，如代理設計模式

     現有類實現擴展時，可以子擴展中遵循協議