iOS学习笔记47-Swift(七)泛型

1、Swift泛型介绍

泛型是为Swift编程灵活性的一种语法，在函数、枚举、结构体、类中都获得充分的应用，它的引入能够起到占位符的做用，当类型暂时不肯定的，只有等到调用函数时才能肯定具体类型的时候能够引入泛型。
咱们以前实际上已经使用过泛型，例如：Swift的Array和Dictionary类型都是泛型集。

你能够建立一个Int数组，也可建立一个String数组，或者甚至于能够是任何其余Swift的类型数据数组。一样的，你也能够建立存储任何指定类型的字典(Dictionary)，并且这些类型能够是没有限制的。

咱们为何要使用泛型呢？下面有个例子能够简单说明使用泛型的好处

//定义一个函数，要求追加数组数据到指定一个数组中 func appendIntToArray(src:[Int],inout dest:[Int]) { // 遍历并加到数组后边 for element in src{ dest.append(element) } } //使用copyIntArray添加整形数组数据 var arr = [2,5] appendIntToArray([12,9], dest: &arr) print(arr) // [2,5,12,9] //那么再要求让你实现添加字符串呢，好吧重写一个 func appendStringToArray(src:[String],inout dest:[String]) { for element in src{ dest.append(element) } } //使用copyStringArray添加字符串数组数据 var strArr = ["oc","swift"] appendStringToArray(["php", "C#"], dest: &strArr) print(strArr) // ["oc", "swift", "php", "C#"] //若是有须要你实现添加其余类型呢？ //是否是每一个类型都须要写一个对应的函数去实现，那这样就太复杂了！这时候咱们就须要使用泛型 //定义泛型函数，在普通函数名后面加上<T>，T是个类型占用符，能够表示任何类型 func appendArray<T>(src:[T],inout dest:[T]) { for element in src { dest.append(element) } } //看到如此强大了吧？而后随意使用 var arr2 = [5,8] appendArray([9,58], dest: &arr2) //appendArray自动识别要添加的数组数据类型 print(arr2) //[5, 8, 9, 58] var strArr2 = ["renhairui","hello"] appendArray(["nihao", "helloworld"], dest: &strArr2) print(strArr2) //["renhairui", "hello", "nihao", "helloworld"] var doubleArr = [1.2,3.4] appendArray([6.5,1.0], dest: &doubleArr) print(doubleArr) //[1.2, 3.4, 6.5, 1.0]

个人理解：泛型就是先占坑，具体占坑作什么，随你

2、Swift泛型使用

Swift泛型相关使用可分为如下几点：

1. 泛型函数
2. 泛型类型
3. 泛型约束
4. 泛型协议

1. 泛型函数，函数参数或返回值类型用泛型表示

//泛型函数定义式 func 函数名<泛型1,泛型2,…>(形参列表)->返回值类型 { //函数体... }

泛型函数使用实例

//定义一个泛型函数，把2个参数的值进行交换 func swapTwoValues<T>(inout valueOne: T, inout valueTwo: T) { let temporaryA = valueOne valueOne = valueTwo valueTwo = temporaryA } //交换2个整形变量 var oneInt = 3 var twoInt = 107 swapTwoValues(&oneInt, valueTwo: &twoInt) print("oneInt = \(oneInt), twoInt = \(twoInt)") //打印：oneInt = 107, twoInt = 3 //交换2个字符串变量 var oneStr = "hello" var twoStr = "world" swapTwoValues(&oneStr, valueTwo: &twoStr) print("oneStr = \(oneStr), twoStr = \(twoStr)") //打印：oneStr = world, twoStr = hello

2. 泛型类型，在定义类型时使用泛型

使用也和泛型函数差很少，就是在类型名后面加上<泛型1,泛型2,…>，而后在类型里面直接使用泛型便可

//定义一个泛型结构体，用于压栈和出栈，泛型类型可使用到类、结构体、枚举等各类类型 struct Stack<T> { //栈在这里是个数组存储形式，数组中存储的数据类型是泛型类型 var items = [T]() //由于压栈会修改实例值，须要加上mutationg关键字 mutating func push(item: T) { items.append(item) } //由于出栈会修改实例值，须要加上mutationg关键字 mutating func pop() -> T { return items.removeLast() } } //建立一个字符串栈，栈里面存的是字符串 var stackOfStrings = Stack<String>() stackOfStrings.push("uno") stackOfStrings.push("dos") stackOfStrings.push("tres") stackOfStrings.push("cuatro") print("出栈：\(stackOfStrings.pop())，栈中还剩：\(stackOfStrings.items)") print("出栈：\(stackOfStrings.pop())，栈中还剩：\(stackOfStrings.items)") print("出栈：\(stackOfStrings.pop())，栈中还剩：\(stackOfStrings.items)") /* 打印： 出栈：cuatro，栈中还剩：["uno", "dos", "tres"] 出栈：tres，栈中还剩：["uno", "dos"] 出栈：dos，栈中还剩：["uno"] */ //建立一个整形栈，栈里面存的是整形 var stackOfInt = Stack<Int>() stackOfInt.push(12) stackOfInt.push(32) stackOfInt.push(45) stackOfInt.push(35) print("出栈：\(stackOfInt.pop())，栈中还剩：\(stackOfInt.items)") print("出栈：\(stackOfInt.pop())，栈中还剩：\(stackOfInt.items)") print("出栈：\(stackOfInt.pop())，栈中还剩：\(stackOfInt.items)") /* 打印： 出栈：35，栈中还剩：[12, 32, 45] 出栈：45，栈中还剩：[12, 32] 出栈：32，栈中还剩：[12] */

压栈：

 

出栈：

 

3. 泛型约束，为泛型类型添加约束

泛型约束大体分为如下几种：

1. 继承约束，泛型类型必须是某个类的子类类型
2. 协议约束，泛型类型必须遵循某些协议
3. 条件约束，泛型类型必须知足某种条件

约束的大概使用格式

//继承约束使用格式 func 函数名<泛型: 继承父类>(参数列表) -> 返回值 { //函数体，泛型类型是某个类的子类类型 } //协议约束使用格式 func 函数名<泛型: 协议>(参数列表) -> 返回值 { //函数体，泛型类型遵循某些协议 } //条件约束使用格式 func 函数名<泛型1, 泛型2 where 条件>(参数列表) -> 返回值 { //函数体，泛型类型知足某些条件 }

继承约束使用范例

//定义一个父类，动物类 class Animal{ //动物都会跑 func run(){ print("Animal run") } } //定义狗类，继承动物类 class Dog: Animal { override func run(){//重写父类方法 print("Dog run") } } //定义猫类，继承动物类 class Cat: Animal { override func run(){//重写父类方法 print("Cat run") } } //定义泛型函数，接受一个泛型参数，要求该泛型类型必须继承Animal func AnimalRunPint<T:Animal>(animal:T){ animal.run() //继承了Animal类的子类都有run方法能够调用 } AnimalRunPint(Dog()) AnimalRunPint(Cat()) /* 打印： Dog run Cat run */

协议约束使用范例

Swift标准库中定义了一个Equatable协议，该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。全部的Swift标准类型自动支持Equatable协议。

//定义泛型函数，为泛型添加协议约束，泛型类型必须遵循Equatable协议 func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { var index = 0 for value in array { if value == valueToFind {//由于遵循了Equatable协议，因此能够进行相等比较 return index } else { index++ } } return nil } //在浮点型数组中进行查找，Double默认遵循了Equatable协议 let doubleIndex = findIndex([3.14159, 0.1, 0.25], valueToFind: 9.3) if let index = doubleIndex { print("在浮点型数组中寻找到9.3，寻找索引为\(index)") } else { print("在浮点型数组中寻找不到9.3") } //在字符串数组中进行查找，String默认遵循了Equatable协议 let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], valueToFind: "Andrea") if let index = stringIndex { print("在字符串数组中寻找到Andrea，寻找索引为\(index)") } else { print("在字符串数组中寻找不到Andrea") } /* 打印： 在浮点型数组中寻找不到9.3 在字符串数组中寻找到Andrea，寻找索引为2 */

4. 泛型协议和条件约束

上面的Equatable协议实际上不是普通的协议，而是泛型协议，假设泛型类型必须遵循一个协议，此时就必须在协议中引入一个关联类型来解决。

//定义一个泛型协议，和其余泛型使用方式不一样，这里泛型是以关联类型形式使用的 protocol Stackable{ //声明一个关联类型，使用typealias关键字 typealias ItemType mutating func push(item:ItemType) mutating func pop() -> ItemType } struct Stack<T>:Stackable{ var store = [T]() mutating func push(item:T){//实现协议的push方法要求 store.append(item) } mutating func pop() -> T {//实现协议的pop方法要求 return store.removeLast() } } //建立Stack结构体，泛型类型为String var stackOne = Stack<String>() stackOne.push("hello") stackOne.push("swift") stackOne.push("world") let t = stackOne.pop() print("t = \(t)") //结果：t = world //添加泛型条件约束，C1和C2必须遵循Stackable协议，并且C1和C2包含的泛型类型要一致 func pushItemOneToTwo<C1: Stackable, C2: Stackable where C1.ItemType == C2.ItemType>(inout stackOne: C1, inout stackTwo: C2) {//由于C1和C2都遵循了Stackable协议，才有ItemType属性能够调用 let item = stackOne.pop() stackTwo.push(item) } //定义另一个结构体类型，一样实现Stackable协议，实际上里面的实现和Stack同样 struct StackOther<T>: Stackable{ var store = [T]() mutating func push(item:T){//实现协议的push方法要求 store.append(item) } mutating func pop() -> T {//实现协议的pop方法要求 return store.removeLast() } } //建立StackOther结构体，泛型类型为String var stackTwo = StackOther<String>() stackTwo.push("where") //虽然stackOne和stackTwo类型不同，但泛型类型同样，也一样遵循了Stackable协议 pushItemOneToTwo(&stackOne, stackTwo: &stackTwo ) print("stackOne = \(stackOne.store), stackTwo = \(stackTwo.store)") //打印：stackOne = ["hello"], stackTwo = ["where", "swift"]