【iOS】Swift扩展extension和协议protocol

加上几个关节前Playground摘要码进入github在，凝视写了非常多，主要是为了方便自己的未来可以Fanfankan。

Swift语法的主要部分几乎相同的。

当然也有通用的、运算符重载、ARC、补充倒闭之类的。

一、扩展（extension）

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

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

extension SomeType{
    //加入到SomeType的新功能写在这里
}

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

//扩展能够加入新计算属性, 可是不能加入存储属性(也不能够加入属性观察).
extension Double{  //为API中的已有类型加入实例属性
    var km : Double { return self * 1_000.0 }
    var m : Double { return self }
    var cm : Double { return self / 100.0 }
}

let jjLength = 1.m  // 1与m进行点运算, 表示1的Double值
let jjLength_km = 1.km
println(10.km + 1.m)

1.2扩展构造器

//能够定制自己的构造器
class MyClass{
    var a : Int
    init(){
        a = 10
    }
}

extension MyClass{
    convenience init(var parm:Int){   //扩展构造器
        self.init()
        println("扩展构造器--->便利构造器, \(parm)")
    }
}

var myClass = MyClass(parm: 9)

1.3扩展方法

以下是像Int中扩展myIntFunc方法

extension Int{
    func myIntFunc(){
        println("值为\(self) , 哈哈哈哈!")
    }
}

1.myIntFunc()

1.3.1 改动实例方法

通过扩展方法, 能够改动该实例self本身.可是方法前要加 mutating

extension Double{
    mutating func myMoidfySelfValue{
        self = self * self //改动self实例的值
    }
}

var d = 2.0
d.myMoidfySelfValue()

1.4 扩展嵌套类型

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

extension Character {
    enum Kind{   //嵌套了一个枚举类型
        case Big
        case Small
    }
    var k : Kind{
        if(String(self).lowercaseString == "a"){
            return Kind.Big
        }else{
            return Kind.Small
        }
    }
}
var ch : Character = "a"
ch.k   //返回一个枚举值Kind.Big

二、协议（protocol）

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

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

protocol SomeProtocol{
    //协议内容
}

class SomeClass : SomeProtocol{ //实现协议, 可实现多个协议

}

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

2.1.1 属性的要求

protocol AnotherProtocol1{
    //class表示类成员(结构体/枚举中用static)
    class var property : Int { get set} //get, set 表示可读可写
}

class AnotherClass1 : AnotherProtocol1{
    class var property : Int {  //实现协议中的属性
        get{
            return 10
        }
        set{

        }
    }
}

2.1.2 方法要求

//不支持默认參数. 写法上仅仅是没有方法的实现.
protocol AnotherProtocol2{
    func myFunc() -> Int   //仅仅声明不实现
}

class AnotherClass2 : AnotherProtocol2{
    func myFunc() -> Int {  //实现方法
        return 10
    }
}

2.1.3 突变方法要求

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

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

protocol Togg{
    mutating func togg()
}

enum OnOffSwitch : Togg{
    case Off , On

    mutating func togg() { //改变实例的值
        switch self{
        case .Off:
            self = On
        case .On:
            self = Off
        }
    }
}

var lightSwitch = OnOffSwitch.Off
lightSwitch.togg()   //值变为On

2.2 协议类型.

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

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

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

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

protocol MyRect{
    func myLuckNumber() -> Int
}

class MyRectImp : MyRect{
    func myLuckNumber() -> Int {
        return 10
    }
}

class Dice {
    let sides :Int
    var gener : MyRect    //作为类型
    init(sides:Int, gener:MyRect){  //作为參数
        self.sides = sides
        self.gener = gener
    }
}

var dice = Dice(sides: 6, gener: MyRectImp())
dice.gener.myLuckNumber()   //返回10

演示样例代码见：http://github.com/xn4545945/SwiftLearning

參考：

The Swift Programming Language  

Apple Dev Center

转载请注明出处：http://blog.csdn.net/xn4545945  

版权声明：本文博主原创文章，博客，未经同意不得转载。