這周有點空 就把學習內容分開寫好了.
之前那周事情比較多文章就快餐的寫完就好了
泛型是一個神奇的語法,當然你學會不感受到他奇妙之處.不要好像我那樣愚挫,成天捉狂.
泛型允許在函數(shù),枚舉,結構,類中,以及協(xié)議上自定義形參
泛型指定一個或多個類型占位符休溶，類型暫時不確定，等具體調用的時候再確定
//標準類型
func swapTwoInts(inout a: Int, inout b: Int){
let temporaryA = a
a = b
b = temporaryA
}
//泛型
func swapTwoValues<T>(inout a: T, inout b: T){
let temporaryA = a
a = b
b = temporaryA
}
//其中T可以是Int和String 還有很多 這里不舉栗子
var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt, &anotherInt)
//這時候T的類型為 int
var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)
//這時候T的類型為 String
////設置U為不合法,應當基類類型或其他函數(shù)類型.
class swapOneValues <T> : swapTwoValues<U>{
//...
}
//參數(shù)實例化
var text1= swapTwoValues <String>()
var text2= swapTwoValues <Double>()
var text3= swapTwoValues <int>()
協(xié)議的關聯(lián)類型<協(xié)議泛型>
protocol Container {
//關聯(lián)類型 typealias可以為protocol定義一到多個管理類型
//關聯(lián)類型也是占位符
//關聯(lián)類型 可以看做為支持"泛型版的協(xié)議"
typealias ItemType
func append(item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }
}
class Stack<T>: Container {
//T= Container.ItemType 可以這樣理解吧
typealias ItemType=T
var items = [T]()
func push(item: T) {
items.append(item)
}
func pop() -> T {
return items.removeLast()
}
func append(item: T) {
self.push(item)
}
var count: Int {
return items.count
}
subscript(i: Int) -> T {
return items[i]
}
}
//泛型使用
var stack1=Stack<String>()
stack1.append("Earth")
var stack2=Stack<Int>()
stack2.append(1)
stack2.append(2)
stack2.count
泛型約束
//協(xié)議約束 + where句子約束
//where約束,指定關聯(lián)類型必須符合某種協(xié)議,或者其他關聯(lián)類型等
func find<T:Container where T.ItemType: Equatable>(sequence :T, item:T.ItemType)->Bool{
for index in 0..<sequence.count{
if(sequence[index]==item){
return true
}
}
return false
}
//T:支持約束類型 Comparable是基類約束,另一種是協(xié)議約束
func max<T:Comparable>(array: [T]) -> T {
var value=array[0]
for index in 1..<array.count
{
if array[index]>value {
value=array[index]
}
}
return value
}