扩展（Extension）

Swift中的扩展，有点类似于OC中的分类(Category)
扩展可以为枚举、结构体、类、协议添加新功能
可以添加方法、计算属性、下标、(便捷)初始化器、嵌套类型、协议等等
扩展不能办到的事情:要注意扩展不能改变原有类的内存结构

不能覆盖原有的功能
不能添加存储属性，不能向已有的属性添加属性观察器（添加存储属性会改变原有类的内存结构）
不能添加父类（由于有可能会继承父类的存储属性，会改变内存结构，所以也不行）
不能添加指定初始化器，不能添加反初始化器，因为它们只能写在原有类里面，所以不能写在扩展里
...

计算属性、下标、方法、嵌套类型

Extension添加计算属性

Extension添加下标

下面的例子是为了防止数组越界：

var arr: Array<Int> = [10, 20, 30]
print(arr.startIndex) //0
print(arr.endIndex) //3 endIndex表示最后一位元素的下一位

extension Array {
    subscript(nullable idx: Int) -> Element? {
        if(startIndex..<endIndex).contains(idx) {
            return self[idx]
        }
        return nil
    }
}

print(arr[nullable: 1] ?? 0)  //20

Extension添加嵌套类型

extension Int {
    func repeatitions(task: () -> Void) {
        for _ in 0..<self {task()}
    }
    
    mutating func square() -> Int {
        self = self * self;
        return self
    }
   //Int中嵌套了一个新的枚举类型
    enum Kind {case negative, zero, positive}
    var kind: Kind {
        switch self {
        case 0: return .zero
        case let x where x > 0: return .positive
        default: return .negative
        }
    }
    
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex { decimalBase *= 10}
        return(self / decimalBase) % 10
    }
}

3.repeatitions {
    print(1)
}// 1  1  1

var b = 10
print(b.square()) // 100

var c = -10
print(c.kind) // negative

var d = 456
print(d[1]) //5 d[1]表示取十位数字 d[0]为6

协议、初始化

extension添加协议

添加Equatable协议和便捷初始化器

extension添加初始化器

如果希望自定义初始化器的同时，编译器也能够生成默认初始化器，可以在扩展中编写自定义初始化器

required初始化器也不能写在扩展中

协议

如果一个类型已经实现了协议的所有要求，但是还没有声明它遵守了这个协议 ,可以通过扩展来让它遵守这个协议

protocol TestProtocal {
    func test()
}
class TestClass {
    func test() {
        print("test")
    }
}

extension TestClass : TestProtocal { }

编写一个函数，判断一个整数是否为奇数?

UInt和Int都属于BinaryInteger类型

扩展可以给协议提供默认实现，也间接实现『可选协议』的效果
扩展可以给协议扩充『协议中从未声明过的方法』

protocol TestProtocal {
    func test1()
}

extension TestProtocal {
    func test1() {
        print("TestProtocal test1")
    }
    func test2() {
        print("TestProtocal test2")
    }
}

class TestClass: TestProtocal { }

var cls = TestClass()
cls.test1() //TestProtocal test1
cls.test2() //TestProtocal test2

var cls2: TestProtocal = TestClass()
cls2.test1() //TestProtocal test1
cls2.test2() //TestProtocal test2

class TestClass1: TestProtocal {
    func test1() { print("TestClass test1")}
    func test2() { print("TestClass test2")}
}
var cls3 = TestClass1()
cls3.test1() //TestClass test1
cls3.test2() //TestClass test2

var cls4: TestProtocal = TestClass1()
cls4.test1() //TestClass test1
cls4.test2() //TestProtocal test2 这里是因为遵守TestProsal协议，并且TestProsal协议里没有test2方法，编译器就会默认遵守协议的类的实例里没有test2方法，就会去扩展里去找

泛型

class Stack<E> {
    var elements = [E]()
    
    func push(_ element: E) {
        elements.append(element)
    }
    func pop() -> E {
       return elements.removeLast()
    }
    func size() -> Int {
        return elements.count
    }
}

extension Stack {
    func top() -> E {
        return elements.last!
    }
}

extension Stack: Equatable where E: Equatable {
    static func == (left: Stack, right: Stack) -> Bool{
       return left.elements == right.elements
    }
}

var sta1 = Stack<Int>()
sta1.push(10)
sta1.push(20)
sta1.push(30)

var sta2 = Stack<Int>()
sta2.push(10)
sta2.push(20)
sta2.push(30)

print(sta1 == sta2) //true

Swift(学习)：扩展（Extension，计算属性，下标，方法，嵌套类型，协议，初始化，泛型）

扩展（Extension）

计算属性、下标、方法、嵌套类型

协议、初始化

协议

泛型

猜你喜欢