Swift基础语法（十一）泛型

Swift基础学习文章汇总

本文将泛型的常见设置方式进行讲解，以及协议使用关联类型的问题和解决

主要内容：

1. 泛型认识
2. 关联类型
3. 类型约束
4. 泛型的实际使用
5. 不透明类型

1. 泛型认识

泛型基本上和Java是一样的，可以用在函数，也可以用在类型上，泛型通过类型参数化，共用类型，提高代码复用率，泛型实现的本质是将类型作为参数传入到函数中。需要注意是否显式写泛型取决于是否已经明确类型

用在函数

代码：

//用在函数
//定义一个交换函数，通过元组交换的，定义T为泛型
func swapValues(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}
//分别交换int、float、struct类型
//传参时就可以决定类型，所以这里的swapValues后面不需要加
var i1 = 10
var i2 = 20
swapValues(&i1, &i2)
    
var d1 = 10.0
var d2 = 20.0
swapValues(&d1, &d2)
    
struct Date {
    var year = 0, month = 0, day = 0
}
var dd1 = Date(year: 2011, month: 9, day: 10)
var dd2 = Date(year: 2012, month: 10, day: 11)
swapValues(&dd1, &dd2)
print(dd1)
print(dd2)
    
//将函数赋给一个变量
var n1 = 10
var n2 = 20
let fn: (inout Int, inout Int) -> () = swapValues
fn(&n1, &n2)
print(n1,n2)//20 10

说明：
1、泛型的含义以及定义和Java一样
2、但是这里调用时不需要传入泛型，比如不能swapValues< Int >，因为传入参数时就可以确定类型
3、赋值给变量需要设置类型，因为此时的swapValues传入的参数就是Int，所以这里需要设置类型

用在类型

代码：

//用在类型
//自定义一个栈，实现简单的出栈入栈,使用elements数组来存储元素
class Stack {
    var elements = [E]()
    func push(_ element: E) {
        elements.append(element)
    }
    func pop() -> E {
        elements.removeLast()
    }
    func top() -> E {
        elements.last!
    }
    func size() -> Int {
        elements.count
    }
}
//这里没有传参，所以需要增加<>类型
var intStack = Stack()
intStack.push(1)
print(intStack.size())
intStack.pop()
print(intStack.size())
var stringStack = Stack()

说明：

1. 需要注意的是这里可以加上< Int >约定类型，因为没有传入参数无法预知类型
2. 如果直接调用Init传入参数来创建对象时，就不需要加上<>了

用在枚举

代码：

//用在枚举
enum Score {
    case point(T)
    case grade(String)
}
//这里虽然使用了grade，没使用point，但是只要创建这个枚举，就应该传入泛型类型
let score = Score.grade("A")

说明：

• 这里虽然没有用用到point，但是也要加上泛型，因为枚举要确定内存结构

2. 关联类型

协议通过关联类型来实现泛型，关联类型可以给协议中用到的类型定义一个占位名称，使用关键字associatedtype来定义。

代码：

/*
 2、关联类型
 其实就是协议的泛型
 */
//创建一个泛型，定义了一个类型Element，该类型遵守Equatable协议
protocol Stackable {
    associatedtype Element : Equatable
}
func test2() {
    //创建一个类，泛型类型必须遵守该协议，并且将该类型赋值给Element
    class Stack : Stackable {
        typealias Element = E
    }
}

说明：
1、泛型可以增加约束，这里是遵守Equatable协议的元素作为泛型
2、因此在类中想要给其赋值，这个E也必须遵守Equatable协议
3、通过typealias Element = E 把泛型设置上

3. 类型约束

代码：

/*
 3、类型约束
 */
//通过where可以增加类型的约束
/*
 约束如下：
 1. S1、S2 都是泛型，
 2. 泛型都遵守协议Stackable
 3. S1和S2的关联类型要相等，这个Element是在类Stack中赋值的，他们要赋值相同
 4. S1的关联类型必须遵守Hashable协议
 */
func equal(_ s1: S1, _s2: S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable {
    return false
}

var stack1 = Stack()
var stack2 = Stack()
var stack3 = Stack()
print(equal(stack1, _s2: stack2))
print(equal(stack1, _s2: stack3))

说明：
1、S1、S2 都是泛型，且泛型都遵守协议Stackable
2、S1和S2的Element要相等，这个Element是在类Stack中赋值的，他们要赋值相同
3、S1的关联类型必须遵守Hashable协议

4. 泛型的实际使用

4.1 代码优化

代码：

/*
 4、应用：代码优化
 */
protocol Runnable {}
class Person : Runnable {}
class Car : Runnable {}

//这里返回值只要写上Runnable，那么返回的只要是遵守该协议的就都可以
//否则每个类型都写一个方法，代码冗余
func get(_ type: Int) -> Runnable {
    if type == 0 {
        return Person()
    }
    return Car()
}

var r1 = get(0)
var r2 = get(1)

说明：

1. 一个类要返回多种类型的方法，就可以使用

4.2 问题

协议中有关联类型，
代码：

报错.jpg

说明：

• 在协议中有关联类型，如果在使用该属性时么有设置该关联类型，就会报错

4.3 解决

4.3.1 使用泛型

代码：

/*
 4、应用：代码优化
 */
protocol Runnable {
    associatedtype Speed
    var speed: Speed { get }
}
class Person : Runnable {
    var speed: Double { 0.0 }
}
class Car : Runnable {
    var speed: Int { 0 }
}

//这里返回值只要写上Runnable，那么返回的只要是遵守该协议的就都可以
//否则每个类型都写一个方法，代码冗余
/*
 增加泛型
 1、方法中传入泛型，该类型必须遵守Runnable协议
 2、最后返回这个类型
 3、当然在返回的时候就需要判断一下是否遵守该协议
 */
func get(_ type: Int) -> T {
    if type == 0 {
        return Person() as! T
    }
    return Car() as! T
}
var r1: Person = get(0)
var r2: Car = get(1)

说明：
1、这里可以明确泛型的类型，这样就可以解决
2、明确返回的类型是Person或Car，这样泛型的Speed就是明确的
3、只不过这里在返回时需要强制转换类型为T

4.3.2 使用不透明类型

代码：

/*
 5、不透明类型
 */
 //这里可以使用some来
func get(_ type: Int) -> some Runnable {
    return Person()
}
var r1 = get(0)
var r2 = get(1)

说明：
1、不透明在于这里外界只知道返回一个遵守runnable协议的类，而不知道具体的类
2、得到的类型所能看到的信息是Runnable，Person类中的信息看不到
3、只能返回一种类型
4、some除了用在返回值类型上，一般还可以用在属性类型上