Swift(學習)：擴充（Extension，計算屬性，下标，方法，嵌套類型，協定，初始化，泛型）

擴充（Extension）

• Swift中的擴充，有點類似于OC中的分類(Category) 
• 擴充可以為枚舉、結構體、類、協定添加新功能
• 可以添加方法、計算屬性、下标、(便捷)初始化器、嵌套類型、協定等等
• 擴充不能辦到的事情:要注意擴充不能改變原有類的記憶體結構

1. 不能覆寫原有的功能 
2. 不能添加存儲屬性，不能向已有的屬性添加屬性觀察器 （添加存儲屬性會改變原有類的記憶體結構）
3. 不能添加父類 （由于有可能會繼承父類的存儲屬性，會改變記憶體結構，是以也不行）
4. 不能添加指定初始化器，不能添加反初始化器，因為它們隻能寫在原有類裡面，是以不能寫在擴充裡
5. ...

計算屬性、下标、方法、嵌套類型

• 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