- 注意！！！！ 如果你是技术大牛、技术大咖，请略过这篇文章避免耽搁您的时间，这篇文章属于入门级别。😀
什么是泛型？
定义的时候不需要指定类型，在客户端使用的时候再去指定类型。举个简单泛型🌰，交换两个数值。可以交换两个Int类型的数值，也可以交换两个Double类型的数值，float 。。。可能每个类型都写一个交换方法，但是参数结构和逻辑结构类似，因此解决方法就是泛型设计
- 方法泛型设计(以swift举例)
//方法泛型
func swipTwoNum<T>(a:inout T, b:inout T) {
let c = a
a = b
b = c
}
//测试
let generics = GenericsTest1()
var num1:Int = 20, num2:Int = 100
generics.swipTwoNum(a: &num1, b: &num2)
var num3:Double = 55.5, num4:Double = 110.5
generics.swipTwoNum(a: &num3, b: &num4)
print("交换之后的 num1 = \(num1) num2 = \(num2) num3 = \(num3) num4 = \(num4)")
- 类泛型设计：类似于方法泛型，目的是让这个类任何的类型都可以使用，而非局限于Int Double float... swift的Array设计就是泛型，这里举例自己写个ArrayList
class ArrayList<T> {
private var array = Array<T>()
func add(obj:T) {
self.array.append(obj)
}
func get(index:Int) -> T {
return self.array[index]
}
func remove(index:Int) {
self.array.remove(at: index)
}
func forEach() {
for item in array {
print(item)
}
}
}
//类泛型设计测试,使用的时候再指定类型
let array = ArrayList<Int>()
array.add(obj: 100)
array.add(obj: 200)
array.add(obj: 300)
let arrayDouble = ArrayList<Double>()
arrayDouble.add(obj: 100.5)
arrayDouble.add(obj: 200.5)
arrayDouble.add(obj: 300.5)
- 泛型的继承(设计遵循开闭原则:修改封闭，扩展开放) 对于swift语言有两种实现方式 第一种swift的特性：extension 第二种：继承。这里使用继承的方式
父类代码
class AbsArrayList<T> {
public var array = Array<T>()
func add(obj:T) {
self.array.append(obj)
}
func get(index:Int) -> T {
return self.array[index]
}
func remove(index:Int) {
self.array.remove(at: index)
}
func forEach() {
for item in array {
print(item)
}
}
}
子类
//泛型的继承
class YSLArrayList<T>: AbsArrayList<T> {
func removeAll() {
self.array.removeAll()
}
}
//泛型继承测试
let array = YSLArrayList<Int>()
array.add(obj: 100)
array.add(obj: 200)
array.add(obj: 300)
array.forEach()
array.removeAll()
- 泛型设计---泛型协议 (让所有ArrayList 实现ArrayPorotol)
协议
//泛型协议
protocol SLIArray {
//定义关联 相当于class 类名之后<TypeArray>的写法 在协议中不允许这种<TypeArray>写法
associatedtype TypeArray
func add(obj:TypeArray)
func remove(index:Int)
func get(index:Int) -> TypeArray?
func removeAll()
func forEach()
}
具体实现
class InheritArrayList<T>: SLIArray {
typealias TypeArray = T
var array = Array<T>()
func add(obj:T) {
self.array.append(obj)
}
func remove(index:Int){
self.array.remove(at: index)
}
func get(index:Int) -> T? {
return self.array[index]
}
func removeAll(){
print("删除全部")
self.array.removeAll()
}
func forEach(){
for item in self.array {
print(item)
}
}
}
泛型协议测试
let array = InheritArrayList<Double>()
array.add(obj: 11.0)
array.add(obj: 21.0)
array.add(obj: 31.0)
array.forEach()
array.removeAll()
- 泛型类型约束 -- 泛型的类型范围，就是限制这个泛型必须是某个类型的子类（子类有很多，这里是指子类的一种）
约束类型格式 ： class 类名<泛型类型名: 约束类型名> {}
举个🌰 我有一个BaseModel,一个UserModel是BaseModel的子类，依旧用ArrayList为泛型示例，代码如下：
//BaseModel
class BaseModel: NSObject {
var token:String?
}
//UserModel
class UserModel: BaseModel {
var password:String?
var userName:String?
}
//ArrayList示例
class YSL_ModelArray<T: BaseModel>: SLIArray {
typealias TypeArray = T
var array = Array<T>()
func add(obj:T) {
self.array.append(obj)
}
func remove(index:Int){
self.array.remove(at: index)
}
func get(index:Int) -> T? {
return self.array[index]
}
func removeAll(){
print("删除全部")
self.array.removeAll()
}
func forEach(){
for item in self.array {
print(item)
}
}
}
//在ViewController中测试一下
//限制泛型协议
let userModel = UserModel()
userModel.password = "123456"
userModel.userName = "Administritor"
let modelArray = YSL_ModelArray<BaseModel>()
modelArray.add(obj: userModel)
modelArray.forEach()
//给泛型加了限制之后，就不能再用任意的其他类型了，如果给个Int、Double 就会报错，必须传BaseModel这一类，图：
WechatIMG.jpeg
