Swift-----扩展extension

1. 类、结构体、枚举都是可以扩展的。

　　（1）可以在扩展中添加方法；

　　（2）可以在扩展中添加属性----这个属性只能是计算型属性，不可以是存储型属性；

　　（3）可以在扩展中添加构造函数----这个构造函数只能是便利构造函数，不可以是指定构造函数。

　　以上可以看到，代码的基石还是在原来的类（结构体、枚举）中的，扩展只能起到辅助的作用。

struct Point {
    
    var x: Double = 0.0
    var y: Double = 0.0
}

struct Size {
    
    var  Double = 0.0
    var height: Double = 0.0
}

class Rectangle {

    var origin = Point()
    var size = Size()
    
    init(origin: Point, size: Size) {
        
        self.origin = origin
        self.size = size
    }
}

extension Rectangle {

    // 扩展方法
    func translate(x: Double, y: Double) {
        
        self.origin.x += x
        self.origin.y += y
    }
    
    // 扩展属性---只能扩展计算型属性，不能扩展存储型属性
    var center: Point {
        
        get {
            let centerX = origin.x + size.width/2
            let centerY = origin.y + size.height/2
            return Point(x: centerX, y: centerY)
        }
        set {
            origin.x = newValue.x - size.width/2
            origin.y = newValue.y - size.height/2
        }
    }
    
    // 扩展构造函数---只能是便利构造函数，不可以是指定构造函数
    convenience init(center: Point, size: Size) {
        
        let originX = center.x - size.width/2
        let originY = center.y - size.height/2
        
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

 2 可以扩展嵌套类型、扩展下标

　　嵌套类型：就是在一个类型中定义另外一个类型。

　　如下可以看到，枚举Theme是在类里面定义的，这个Theme其实就是嵌套类型。　

class UI {    
    enum Theme {
        case DayMode
        case NightMode
    }
}

extension Rectangle {

    // 扩展类型嵌套
    enum Vertex: Int {
        case LeftTop
        case RightTop
        case LeftBottom
        case RightBottom
    }
    
    func pointAtVertex(v: Vertex) -> Point {
        switch (v) {
        case .LeftTop:
            return origin
        case .RightTop:
            return Point(x: origin.x + size.width, y: origin.y)
        case .LeftBottom:
            return Point(x: origin.x, y: origin.y + size.height)
        case .RightBottom:
            return Point(x: origin.x + size.width, y: origin.y + size.height)
        }
    }
    
    // 扩展下标
    subscript(index: Int) -> Point {
        
        assert(index >= 0 && index < 4, "Index out of range.")
        
        return pointAtVertex(v: Vertex(rawValue: index)!)
    }
}

3 对系统类进行扩展----对Int扩展（这其实就是函数式编程的思想）

extension Int {
    
    // 平方
    var square: Int {
        return self * self
    }
    
    // 立方
    var cude: Int {
        return self * self * self
    }
    
    //将“num >= 0 && num < 20”这种判断扩展为一个方法
    func inRange(closedLeft: Int, openRight: Int) -> Bool {
        return self >= closedLeft && self < openRight
    }
    
    // 将“for i in 0 ..< num”这种循环扩展为一个方法
    func repetitions(task: (Int) -> ()) {
        
        for i in 0 ..< self {
            task(i)
        }
    }    
}

var num = 8
8.square
8.cude

num >= 0 && num < 20
8.inRange(closedLeft: 0, openRight: 20)

for i in 0 ..< num {
    print("Hello----(i)")
}
num.repetitions { i in
    print("Hello----(i)")
}