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 = ""

        varprice:Double=0.0

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

        varhouseUnitPrice: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 ()

    varp2:protocol<AProtocol,BProtocol> =BStruct()

协议的应用场合：

     一定程度上实现了多继承的功能

     常见的设计模式中，如代理设计模式

     现有类实现扩展时，可以子扩展中遵循协议

本文出自 “安萌” 博客，请务必保留此出处http://annmeng.blog.51cto.com/3321237/1747069

原文：http://annmeng.blog.51cto.com/3321237/1747069