拓展和泛型 · swift笔记

# Swift 拓展和泛型 ## Swift 拓展 Extension ### 扩展计算型属性和便利构造函数 ``` struct Point { var x = 0.0 var y = 0.0 } struct Size { var width = 0.0 var height = 0.0 } class Rectangle { var origin = Point() var size = Size() init (origin: Point, size: Size) { self.origin = origin self.size = size } } // 拓展 Rectangle extension Rectangle { func translate(x: Double,y: Double) { self.origin.x += x self.origin.y += y } } let rect = Rectangle(origin: Point(), size: Size(width: 4, height: 5)) rect.translate(x: 10, y: 10) rect // 扩展计算型属性和扩展便利构造函数 extension Rectangle{ // var center: Point = Point() // 不允许扩展存储型属性 var center: Point { get{ let centerX = origin.x + size.width/2 let centerY = origin.y + size.height/2 return Point(x: centerX, y: centerY) } set{ origin.x = newValue.x - size.width/2 origin.y = newValue.y - size.height/2 } } // 扩展构造函数 - 扩展中加入构造函数必须是一个便利的 convenience 构造函数，使用 self.init() 的方式引用当前对象实例化的指定构造函数 convenience init(center: Point, size: Size){ let originX = center.x - size.width/2 let originY = center.y - size.height/2 self.init(origin: Point(x: originX, y: originY),size: size) } } ``` ### 扩展嵌套枚举 ``` class UI{ enum Theme{ case DayMode case NightMode } var fontColor: UIColor! var backgroundColor: UIColor! var themeMode: Theme = .DayMode{ didSet{ self.changeTheme(themeMode: self.themeMode) } } init(){ self.themeMode = .DayMode self.changeTheme(themeMode: self.themeMode) } init(themeMode: Theme){ self.themeMode = themeMode self.changeTheme(themeMode: themeMode) } func changeTheme( themeMode: Theme ){ switch(themeMode){ case .DayMode: fontColor = UIColor.black backgroundColor = UIColor.white case .NightMode: fontColor = UIColor.white backgroundColor = UIColor.black } } } let ui = UI() ui.themeMode ui.fontColor ui.backgroundColor ui.themeMode = UI.Theme.NightMode ui.themeMode ui.fontColor ui.backgroundColor ``` ### 使用 extension 扩展系统类库 ``` extension Int{ // 计算平方 var square: Int{ return self * self } // 计算立方 var cube: Int{ return self * self * self } // 扩展方法判断整型是否在前闭后开的范围内 func inRange(closedLeft left: Int, opendRight right: Int) -> Bool { return self >= left && self < right } // 扩展方法 func repetitions( task: () -> Void ){ for _ in 0 ..< self { task() } } } let num = 8 num.square // 64 num.cube // 512 let index = 10 index.inRange(closedLeft: 0, opendRight: 20) // 判断 index 是否在 0 ..< 20 num.repetitions{ print("Hello,Swift!") } ``` ## Swift 泛型 Generic 泛型：是指有一套通用的逻辑，不与类型相关。例如交换两个参数的值，如下： ``` func swapTwoInt( _ a: inout Int , _ b: inout Int) { (a,b) = (b,a) } var a: Int = 0 var b: Int = 6 swapTwoInt(&a, &b) a b // 上述函数定义中，如果需求要交换两个浮点数，那么我们又需要定义类似如下函数来适应变化。 func swapTwoDouble(_ a: inout Double , _ b: inout Double) { (a,b) = (b,a) } ``` > 以上函数不管是交换整型还是交换浮点型，都是给两个遍历交换相互的值。那我们可以通过泛型对这种需求做改进。 ``` // generic function func swapTwoThings<T>(_ a: inout T , _ b: inout T) { (a,b) = (b,a) } var hello = "Hello" var bye = "Bye" swapTwoThings(&hello, &bye) hello bye swapTwoThings(&a, &b) a b swap(&a, &b) // Swift 中的一个泛型函数 ``` > 使用泛型可以创建更加通用的函数。 ### 泛型类型泛型函数与泛型语法。 ``` let arr:Array<Int> = Array<Int>() let dict = Dictionary<String,Int>() let set = Set<Float>() // 创建自定义数据结构栈（后进先出） struct Stack<T>{ // 存储栈的内容，数组类型 var items = [T]() func isEmpty() -> Bool{ return items.count == 0 } mutating func push(item: T) { items.append(item) } mutating func pop() -> T? { guard !self.isEmpty() else { return nil } return items.removeLast() } } // 扩展 Stack extension Stack{ func top() -> T? { return items.last } func count() -> Int { return items.count } } var s = Stack<Int>() // 存储Int类型的栈 s.push(item: 1) s.push(item: 2) s.pop() // 2 var ss = Stack<String>() // 声明存储String类型的栈 ss.top() // nil // 两个数据类型的泛型 struct Pair<T1,T2> { // 取不同的泛型类型名称 var a: T1 var b: T2 } var pair = Pair<Int,String>(a: 0 , b: "Hello") // 成功创建两个数据类型的泛型 pair ```