1.常量与变量
什么是常量和变量 在Swift中规定：在定义一个标识符时必须明确说明该标识符是一个常量还是变量 使用let来定义常量，定义之后不可以修改 使用var来定义变量，定义之后可以修改 变量的基本使用 import UIKit let a : Int = 10 // 错误写法,当一个标识符定义为常量时是不可以修改的 // a = 20 var b : Int = 20 // 因为b定义为变量,因此是可以修改的 b = 30 常量和变量的使用注意: 注意: 在真实使用过程中,建议先定义常量,如果需要修改再修改为变量(更加安全) 是指向的对象不可以再进行修改.但是可以通过指针获得对象后,修改对象内部的属性 import UIKit /* 常量使用注意： 1> 优先使用常量 2> 常量的本质 */ // 1.注意一：在开发中let/var在选择时优先使用常量，防止不小被修改掉（let） // 如果一个标识符不需要修改，但是声明称了变量，那么编译器会报警告 // 2.常量的本质： // 含义：指向的内存地址不可以修改，但是可以通过内存地址，找到对应的对象，之后修改对象内部的属性 /* OC中创建对象： UIView *view = [[UIView alloc] init]; view = [[UIView alloc] init]; Swift中创建对象： var view : UIView = UIView() */ /* 变量的做法 var view : UIView = UIView() view = UIView() */ // 创建常量View let view = UIView() // view = UIView() 错误做法 view.alpha = 0.5 // Swift中创建结构体：结构体类型() view.frame = CGRect(x: 0, y: 0, width: 100, height: 100) // Swift中调用方法，统一使用点语法 view.backgroundColor = UIColor.red 创建对象补充 创建UIView对象，并且在UIView中添加UIButton import UIKit // 1.创建UIView对象 // OC : [[UIView alloc] initWithFrame:CGRect] let viewRect = CGRect(x: 0, y: 0, width: 100, height: 100) let view : UIView = UIView(frame: viewRect) // 2.设置UIView的属性 view.backgroundColor = UIColor.orange // 3.创建UIButton let btn : UIButton = UIButton(type: .custom) // 4.设置UIButton的属性 btn.frame = CGRect(x: 0, y: 0, width: 50, height: 50) btn.backgroundColor = UIColor.purple /* Swift中枚举类型： 1> 如果可以根据上下文推导出类型可以直接.具体的类型 2> 如果根据上下文推导不出具体的类型，则需要：类型.具体的类型 */ btn.setTitle("按钮", for: .normal) btn.setTitleColor(UIColor.white, for: .normal) // 5.将btn添加到UIView中 view.addSubview(btn)
2.数据类型
Swift类型的介绍 Swift中的数据类型也有:整型/浮点型/对象类型/结构体类型等等 先了解整型和浮点型 整型 有符号 Int8 : 有符号8位整型 Int16 : 有符号16位整型 Int32 : 有符号32位整型 Int64 : 有符号64位整型 Int : 和平台相关(默认,相当于OC的NSInteger) 无符号 UInt8 : 无符号8位整型 UInt16 : 无符号16位整型 UInt32 : 无符号32位整型 UInt64 : 无符号64位整型 UInt : 和平台相关(常用,相当于OC的NSUInteger)(默认) 浮点型 Float : 32位浮点型 Double : 64浮点型(默认) // 定义一个Int类型的变量m,并且赋值为10 var m : Int = 10 // 定义一个Double类型的常量n,并且赋值为3.14 let n : Double = 3.14 Swift中的类型推导 Swift是强类型的语言 Swift中任何一个标识符都有明确的类型 注意: 如果定义一个标识符时有直接进行赋值,那么标识符后面的类型可以省略. 因为Swift有类型推导,会自动根据后面的赋值来决定前面的标识符的数据类型 可以通过option+鼠标左键来查看变量的数据类型 /* 类型推导 1> Swift中任何一个标识符都有自己明确的类型 2> 如果定义一个标识符时有直接给该标识符进行赋值，那么标识符后面的类型可以省略 3> 编译器会自动根据后面赋值的类型，推导出前面标识符的类型 4> 可以根据option + 鼠标左键，查看标识符的类型 */ // m是Int类型 let m = 20 // n是Double类型 let n = 2.44 // view是UIView类型 var view = UIView() // color是UIColor类型 let color = UIColor.red Swift中基本运算 Swift中在进行基本运算时必须保证类型一致,否则会出错 相同类型之间才可以进行运算 因为Swift中没有隐式转换 数据类型的转化 Int类型转成Double类型:Double(标识符) Double类型转成Int类型:Int(标识符) import UIKit let m = 20 let n = 30.5 // 错误写法 : // Swift中没有隐式转化，不会自动将一个Int类型转成Double类型，因此不同类型之间不能进行运算 // let result = m + n // 正确做法 // 1> 将Int类型转成Double ： Double(标识符) // 2> 将Double类型转成Int ： Int(标识符) let result1 = Double(m) + n let result2 = m + Int(n)
3.逻辑分支
一. 分支的介绍 分支即if/switch/三目运算符等判断语句 通过分支语句可以控制程序的执行流程 二. if分支语句 和OC中if语句有一定的区别 判断句可以不加() 在Swift的判断句中必须有明确的真假 不再有非0即真 必须有明确的Bool值 Bool有两个取值:false/true // 演练一: let a = 10 // 错误写法: //if a { // print("a") //} // 正确写法 if a > 9 { print(a) } // 演练二: let score = 87 if score < 60 { print("不及格") } else if score <= 70 { print("及格") } else if score <= 80 { print("良好") } else if score <= 90 { print("优秀") } else { print("完美") } 二.guard的使用 guard是Swift2.0新增的语法 它与if语句非常类似，它设计的目的是提高程序的可读性 guard语句必须带有else语句，它的语法如下： 当条件表达式为true时候跳过else语句中的内容，执行语句组内容 条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw guard 条件表达式 else { // 条换语句 break } 语句组 例子 var age = 18 func online(age : Int) -> Void { guard age >= 18 else { print("回家去") return } print("可以上网") } online(age) 三.switch分支 switch的介绍 Switch作为选择结构中必不可少的语句也被加入到了Swift中 只要有过编程经验的人对Switch语句都不会感到陌生 但苹果对Switch进行了大大的增强，使其拥有其他语言中没有的特性 switch的简单使用 基本用法和OC用法一致 不同之处: switch后可以不跟() case后可以不跟break(默认会有break) 例子: let sex = 0 switch sex { case 0 : print("男") case 1 : print("女") default : print("其他") } 简单使用补充: 一个case判断中,可以判断多个值 多个值以,隔开 let sex = 0 switch sex { case 0, 1: print("正常人") default: print("其他") } 简单使用补充: 如果希望出现之前的case穿透,则可以使用关键字fallthrough let sex = 0 switch sex { case 0: fallthrough case 1: print("正常人") default: print("其他") } switch支持区间判断 什么是区间? 通常我们指的是数字区间:0~10,100~200 swift中的区间常见有两种 半开半闭区间:0..<10 表示:0~9,不包括10 闭区间:0…10 表示:0~10 let score = 88 switch score { case 0..<60: print("不及格") case 60..<80: print("几个") case 80..<90: print("良好") case 90..<100: print("优秀") default: print("满分") }
4.循环使用
循环的介绍 在开发中经常会需要循环 常见的循环有:for/while/do while. 这里我们只介绍for/while,因为for/while最常见 for循环的写法 区间for循环 for i in 0..<10 { print(i) } for i in 0...10 { print(i) } 特殊写法 如果在for循环中不需要用到下标i for _ in 0..<10 { print("hello") } while和do while循环 while循环 while的判断句必须有正确的真假,没有非0即真 while后面的()可以省略 var a = 0 while a < 10 { a++ } do while循环 使用repeat关键字来代替了do let b = 0 repeat { print(b) b++ } while b < 20
二、Foundation 的使用
1.字符串使用
字符串的介绍 字符串在任何的开发中使用都是非常频繁的 OC和Swift中字符串的区别 在OC中字符串类型时NSString,在Swift中字符串类型是String OC中字符串@””,Swift中字符串”” 使用 String 的原因 String 是一个结构体，性能更高 NSString 是一个 OC 对象，性能略差 String 支持直接遍历 Swift 提供了 String 和 NSString 之间的无缝转换 字符的定义 定义不可变字符串 // 1> 定义不可变字符串 : 使用let修饰 let str : String = "hello swift" // str = "hello Objective-C" 错误写法 定义可变字符串 // 2> 定义可变字符串 : 使用var修饰 var strM : String = "hello world" strM = "hello china" 字符串的使用 获取字符串的长度 获取字符集合,再获取集合的count属性 let count = str.characters.count 字符串拼接 两个字符串的拼接 let str1 = "Hello" let str2 = "World" let str3 = str1 + str2 字符串和其他数据类型的拼接 let name = "why" let age = 18 let info = "my name is \(name), age is \(age)" 字符串的格式化 比如时间:03:04 let min = 3 let second = 4 let time = String(format: "%02d:%02d", arguments: [min, second]) 字符串的截取 Swift中提供了特殊的截取方式 该方式非常麻烦 Index创建较为麻烦 简单的方式是将String转成NSString来使用 在标识符后加:as NSString即可 let urlString = "www.520it.com" // Swift中通过 as 关键字可以将String类型转成NSString的类型 let header1 = (urlString as NSString).substring(to: 3) let footer1 = (urlString as NSString).substring(from: 10) let range1 = NSRange(location: 4, length: 5) let middle1 = (urlString as NSString).substring(with: range1) swift截取方式 let urlString = "www.520it.com" let headerIndex = urlString.index(urlString.startIndex, offsetBy: 3) let header2 = urlString.substring(to: headerIndex) let footerIndex = urlString.index(urlString.endIndex, offsetBy: -3) let footer2 = urlString.substring(from: footerIndex) let startIndex = urlString.index(urlString.startIndex, offsetBy: 4) let endIndex = urlString.index(urlString.startIndex, offsetBy: 9) let range2 = Range(startIndex..<endIndex) let middle2 = urlString.substring(with: range2)
2.数组的使用
数组的介绍 数组（Array）是一串有序的由相同类型元素构成的集合 数组中的集合元素是有序的，可以重复出现 Swift中的数组 swift数组类型是Array，是一个泛型集合 数组的初始化 数组分成:可变数组和不可变数组 使用let修饰的数组是不可变数组 使用var修饰的数组是可变数组 定义不可变数组 let array : [Any] = ["why", 18, 1.88] 定义可变数组 var arrayM = [Any]() 对数组的基本操作 // 添加数据 array.append("yz") // 删除元素 array.removeFirst() // 修改元素 array[0] = "why" // 取值 array[1] 数组的遍历 // 遍历数组 for i in 0..<array.count { print(array<i>) } // forin方式 for item in array { print(item) } // 设置遍历的区间 for item in array[0..<2] { print(item) } // 遍历数组的同时获取下标值 let names = ["why", "yz", "lnj", "lmj"] for (index, name) in names.enumerate() { print(index) print(name) } 数组的合并 // 数组合并 // 注意:只有相同类型的数组才能合并 var array = ["why", "lmj","lnj"] var array1 = ["yz", "wsz"] var array2 = array + array1; // 不建议一个数组中存放多种类型的数据 var array3 = [2, 3, "why"] var array4 = ["yz", 23] array3 + array4
3.字典的使用
字典的介绍 字典允许按照某个键来访问元素 字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合 键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的 Swift中的字典 Swift字典类型是Dictionary，也是一个泛型集合 字典的初始化 Swift中的可变和不可变字典 使用let修饰的数组是不可变字典 使用var修饰的数组是可变字典 // 定义一个可变字典 var dict1 : [String : Any] = [String : Any]() // 定义一个不可变字典 let dict2 : [String : Any] = ["name" : "why", "age" : 18] 字典的基本操作 // 添加数据 dict["height"] = 1.88 dict["weight"] = 70.0 dict // 删除字段 dict.removeValueForKey("height") dict // 修改字典 dict["name"] = "lmj" dict.updateValue("lmj", forKey: "name") dict // 查询字典 dict["name"] 字典的遍历 // 遍历字典中所有的值 for value in dict.values { print(value) } // 遍历字典中所有的键 for key in dict.keys { print(key) } // 遍历所有的键值对 for (key, value) in dict { print(key) print(value) } 字典的合并 // 字典的合并 var dict1 = ["name" : "yz", "age" : 20] var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"] // 字典不可以相加合并 for (key, value) in dict1 { dict2[key] = value }
4.元组的使用
元组的介绍 元组是Swift中特有的,OC中并没有相关类型 它是什么呢? 它是一种数据结构，在数学中应用广泛 类似于数组或者字典 可以用于定义一组数据 组成元组类型的数据可以称为“元素” 元组的定义 元组的常见写法 // 使用元组描述一个人的信息 ("1001", "张三", 30, 90) // 给元素加上元素名称,之后可以通过元素名称访问元素 (id:"1001", name:"张三", english_score:30, chinese_score:90) 元组的简单使用 用元组来描述一个HTTP的错误信息 // 元组:HTTP错误 // let array = [404, "Not Found"] // 写法一: let error = (404, "Not Found") print(error.0) print(error.1) // 写法二: let error = (errorCode : 404, errorInfo : "Not Found") print(error.errorCode) print(error.errorInfo) // 写法三: let (errorCode, errorIno) = (404, "Not Found") print(errorCode) print(errorIno)
5.可选类型的使用
可选类型的介绍 注意: 可选类型时swift中较理解的一个知识点 暂时先了解,多利用Xcode的提示来使用 随着学习的深入,慢慢理解其中的原理和好处 概念: 在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型) 在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言) 但是开发中赋值nil,在所难免.因此推出了可选类型 可选类型的取值: 空值 有值 定义可选类型 定义一个可选类型有两种写法 最基本的写法 语法糖(常用) // 错误写法 // let string : String = nil // 正确写法: // 注意:name的类型是一个可选类型,但是该可选类型中可以存放字符串. // 写法一:定义可选类型 let name : Optional<String> = nil // 写法二:定义可选类型,语法糖(常用) let name : String? = nil 可选类型的使用 // 演练一:给可选类型赋值 // 定义可选类型 var string : Optional<String> = nil // 给可选类型赋值 // 错误写法:因此该可选类型中只能存放字符串 string = 123 // 正确写法: string = "Hello world" // 打印结果 print(string) // 结果:Optional("Hello world")\n // 因为打印出来的是可选类型,所有会带Optional // 演练二:取出可选类型的值 // 取出可选类型的真实值(解包) print(string!) // 结果:Hello world\n // 注意:如果可选类型为nil,强制取出其中的值(解包),会出错 string = nil print(string!) // 报错 // 正确写法: if string != nil { print(string!) } // 简单写法:为了让在if语句中可以方便使用string // 可选绑定 if let str = string { print(str) } 真实应用场景 目的:让代码更加严谨 // 1.将字符串类型转成Int类型 let str = "123" let result : Int? = Int(str) // nil/Int // 2.根据文件名称,读取路径 let path : String? = Bundle.main.path(forResource: "123.plist", ofType: nil) // 3.根据string,创建URL let url = URL(string: "http://www.520it.com/小码哥") // 4.从字典中取内容 let dict : [String : Any] = ["name" : "why", "age" : 18] dict["name"] dict["height"]
6.类型转化（as）
常见的类型转化符号 as : 将实例转成某一种类型 例子 // 1.定义数组 let array : [AnyObject] = [12, "why", 1.88] // 2.取出第二个元素 let objc = array[1] // 3.将objc转成真正的类型来使用 // 3.1.as? 将AnyObject转成可选类型,通过判断可选类型是否有值,来决定是否转化成功了 let age = objc as? Int print(age) // 结果:Optional(12) // 3.2.as! 将AnyObject转成具体的类型,但是注意:如果不是该类型,那么程序会崩溃 let age1 = objc as! Int print(age1) // 结果:12
7.函数使用
函数的介绍 函数相当于OC中的方法 函数的格式如下 func 函数名(参数列表) -> 返回值类型 { 代码块 return 返回值 } func是关键字,多个参数列表之间可以用逗号（,）分隔，也可以没有参数 使用箭头“->”指向返回值类型 如果函数没有返回值，返回值为Void.并且“-> 返回值类型”部分可以省略 常见的函数类型 // 1.没有参数,没有返回值的函数 func about() -> Void { print("iPhone7") } about() func about1() { print("iPhone7") } about1() // 2.有参数, 没有返回值的函数 func callPhone(phoneNum : String) { print("打电话给\(phoneNum)") } callPhone(phoneNum: "+86 110") // 3.没有参数, 有返回值的函数 func readMsg() -> String { return "吃饭了吗?" } let msg = readMsg() // 4.有参数有返回值的函数 func addTwoNum(num1 : Int, num2 : Int) -> Int { return num1 + num2 } let result = addTwoNum(num1: 20, num2: 30) 函数的使用注意 注意一: 外部参数和内部参数 在函数内部可以看到的参数,就是内部参数 在函数外面可以看到的参数,就是外部参数 默认所有的参数都是外部参数和内部参数 如果不想要外部参数,可以在参数名称前加_ // 1.内部参数&外部参数 /* func sum(num1 : Int, num2 : Int) -> Int { return num1 + num2 } sum(num1: 20, num2: 30) */ /* func sum(_ num1 : Int,_ num2 : Int) -> Int { return num1 + num2 } sum(20, 30) */ func sum(abc num1 : Int, cba num2 : Int) -> Int { return num1 + num2 } sum(abc: 20, cba: 30) // sum(20, 30) 注意二: 可变参数 swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数 它们必须具有相同的类型 我们可以通过在参数类型名后面加入（…）的方式来指示这是可变参数 // 2.可变参数 func sum(nums : Int...) -> Int { var total = 0 for num in nums { total += num } return total } sum(nums: 20, 30, 40, 50) func myPrint(_ items : Any...) { var strM : String = "\(items[0])" for i in 1..<items.count { strM = strM + " " + "\(items<i>)" } print(strM) } print(20, 30, 40) myPrint(20, 30, 40) 注意三: 默认参数 某些情况,如果没有传入具体的参数,可以使用默认参数 func makeCoffee(coffeeName : String = "雀巢") { print("制作了一杯爱心\(coffeeName)咖啡") } makeCoffee(coffeeName: "拿铁") makeCoffee(coffeeName: "摩卡") makeCoffee() 注意四: 引用类型(指针的传递) 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址 必须是变量,因为需要在内部改变其值 Swift提供的inout关键字就可以实现 对比下列两个函数 // 4.指针参数 var m = 20 var n = 30 func swapNum(num1 : inout Int, num2 : inout Int) { let temp = num1 num1 = num2 num2 = temp } swap(&m, &n) print("m:\(m) n:\(n)")
8.枚举类型
枚举类型的介绍 概念介绍 枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。 在 C/OC 语言中枚举指定相关名称为一组整型值 Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值.也可以提供一个值是字符串，一个字符，或是一个整型值或浮点值 枚举类型的语法 使用enum关键词并且把它们的整个定义放在一对大括号内 enum SomeEnumeration { // enumeration definition goes here } 枚举类型的定义 以下是指南针四个方向的一个例子 case关键词表明新的一行成员值将被定义 不像 C 和 Objective-C 一样，Swift 的枚举成员在被创建时不会被赋予一个默认的整数值 在上面的CompassPoints例子中，North，South，East和West不是隐式的等于0，1，2和3 enum CompassPoint { case North case South case East case West } 定义方式二:多个成员值可以出现在同一行上 enum Planet { case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune } 给枚举类型赋值 枚举类型赋值可以是字符串/字符/整型/浮点型 注意如果有给枚举类型赋值,则必须在枚举类型后面明确说明具体的类型 // 1.枚举类型的赋值 enum CompassPoint : Int { case North = 1 case South = 2 case East = 3 case West = 4 } enum Planet { case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune } // 2.枚举类型的使用 let p = Planet(rawValue: 3) if let p = p { switch p { case .Mercury: print("Mercury") case .Venus: print("Venus") case .Earth: print("Mercury") case .Mars: print("Mars") case .Jupiter: print("Jupiter") case .Saturn: print("Saturn") case .Uranus: print("Uranus") case .Neptune: print("Neptune") } }
9.结构体介绍
结构体的介绍 概念介绍 结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合 结构体(struct)指的是一种数据结构 结构体是值类型,在方法中传递时是值传递 结构的定义格式 struct 结构体名称 { // 属性和方法 } 结构体的使用 定义&使用结构体 // 初始化结构体 struct Location { var x : Double var y : Double } // 创建结构体 let location = Location(x: 90, y: 90) 结构体的增强 扩充构造函数 默认情况下创建Location时使用Location(x: x值, y: y值) 但是为了让我们在使用结构体时更加的灵活,swift还可以对构造函数进行扩充 扩充的注意点 在扩充的构造函数中必须保证成员变量是有值的 扩充的构造函数会覆盖原有的构造函数 struct Location { var x : Double var y : Double init(x : Double, y : Double) { self.x = x self.y = y } init(xyString : String) { let strs = xyString.componentsSeparatedByString(",") x = Double(strs.first!)! y = Double(strs.last!)! } } let location = Location(x: 100, y: 100) let location1 = Location(xyString: "100,100") 为结构体扩充方法 为了让结构体使用更加灵活,swift的结构体中可以扩充方法 例子:为了Location结构体扩充两个方法 向水平方向移动的方法 向垂直方向移动的方法 struct Location { var x : Double var y : Double init(x : Double, y : Double) { self.x = x self.y = y } init(xyString : String) { let strs = xyString.componentsSeparatedByString(",") x = Double(strs.first!)! y = Double(strs.last!)! } mutating func moveH(x : Double) { self.x += x } mutating func moveV(y : Double) { self.y += y } } 注意: 如果我们使用的Location不是自己定义的，但是我们仍旧希望在自己的项目里扩展Location的操作 Swift也能帮我们达成，这个机制，叫做extension extension Location { mutating func moveH(x : Double) { self.x += x } mutating func moveV(y : Double) { self.y += y } }
10、类的定义
主要内容 类的介绍和定义 类的属性 类的构造函数 一. 类的介绍和定义 Swift也是一门面向对象开发的语言 面向对象的基础是类,类产生了对象 在Swift中如何定义类呢? class是Swift中的关键字,用于定义类 class 类名 : SuperClass { // 定义属性和方法 } 注意: 定义的类,可以没有父类.那么该类是rootClass 通常情况下,定义类时.继承自NSObject(非OC的NSObject) 二. 如何定义类的属性 类的属性介绍 Swift中类的属性有多种 存储属性:存储实例的常量和变量 计算属性:通过某种方式计算出来的属性 类属性:与整个类自身相关的属性 存储属性 存储属性是最简单的属性，它作为类实例的一部分，用于存储常量和变量 可以给存储属性提供一个默认值，也可以在初始化方法中对其进行初始化 下面是存储属性的写法 age和name都是存储属性,用来记录该学生的年龄和姓名 chineseScore和mathScore也是存储属性,用来记录该学生的语文分数和数学分数 class Student : NSObject { // 定义属性 // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 } // 创建学生对象 let stu = Student() // 给存储属性赋值 stu.age = 10 stu.name = "why" stu.chineseScore = 89.0 stu.mathScore = 98.0 计算属性 计算属性并不存储实际的值，而是提供一个getter和一个可选的setter来间接获取和设置其它属性 计算属性一般只提供getter方法 如果只提供getter，而不提供setter，则该计算属性为只读属性,并且可以省略get{} 下面是计算属性的写法 averageScore是计算属性,通过chineseScore和mathScore计算而来的属性 在setter方法中有一个newValue变量,是系统指定分配的 class Student : NSObject { // 定义属性 // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 // 计算属性 var averageScore : Double { get { return (chineseScore + mathScore) / 2 } // 没有意义,因为之后获取值时依然是计算得到的 // newValue是系统分配的变量名,内部存储着新值 set { self.averageScore = newValue } } } // 获取计算属性的值 print(stu.averageScore) 类属性 类属性是与类相关联的，而不是与类的实例相关联 所有的类和实例都共有一份类属性.因此在某一处修改之后,该类属性就会被修改 类属性的设置和修改,需要通过类来完成 下面是类属性的写法 类属性使用static来修饰 courseCount是类属性,用来记录学生有多少门课程 class Student : NSObject { // 定义属性 // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 // 计算属性 var averageScore : Double { get { return (chineseScore + mathScore) / 2 } // 没有意义.newValue是系统分配的变量名,内部存储着新值 set { self.averageScore = newValue } } // 类属性 static var corseCount : Int = 0 } // 设置类属性的值 Student.corseCount = 3 // 取出类属性的值 print(Student.corseCount) 监听属性的改变 在OC中我们可以重写set方法来监听属性的改变 Swift中可以通过属性观察者来监听和响应属性值的变化 通常是监听存储属性和类属性的改变.(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化) 我们通过设置以下观察方法来定义观察者 willSet：在属性值被存储之前设置。此时新属性值作为一个常量参数被传入。该参数名默认为newValue，我们可以自己定义该参数名 didSet：在新属性值被存储后立即调用。与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法 监听的方式如下: 监听age和name的变化 class Person : NSObject { var name : String? { // 可以给newValue自定义名称 willSet (new){ // 属性即将改变,还未改变时会调用的方法 // 在该方法中有一个默认的系统属性newValue,用于存储新值 print(name) print(new) } // 可以给oldValue自定义名称 didSet (old) { // 属性值已经改变了,会调用的方法 // 在该方法中有一个默认的系统属性oldValue,用于存储旧值 print(name) print(old) } } var age : Int = 0 var height : Double = 0.0 } let p : Person = Person() // 在赋值时,监听该属性的改变 // 在OC中是通过重写set方法 // 在swift中,可以给属性添加监听器 p.name = "why" //p.name = "yz"
11、类的构造函数
构造函数的介绍 构造函数类似于OC中的初始化方法:init方法 默认情况下载创建一个类时,必然会调用一个构造函数 即便是没有编写任何构造函数，编译器也会提供一个默认的构造函数。 如果是继承自NSObject,可以对父类的构造函数进行重写 构造函数的基本使用 构造函数的基本使用 类的属性必须有值 如果不是在定义时初始化值,可以在构造函数中赋值 class Person: NSObject { var name : String var age : Int // 重写了NSObject(父类)的构造方法 override init() { name = "" age = 0 } } // 创建一个Person对象 let p = Person() 初始化时给属性赋值 很多时候,我们在创建一个对象时就会给属性赋值 可以自定义构造函数 注意:如果自定义了构造函数,会覆盖init()方法.即不在有默认的构造函数 class Person: NSObject { var name : String var age : Int // 自定义构造函数,会覆盖init()函数 init(name : String, age : Int) { self.name = name self.age = age } } // 创建一个Person对象 let p = Person(name: "why", age: 18) 字典转模型(初始化时传入字典) 真实创建对象时,更多的是将字典转成模型 注意: 去字典中取出的是NSObject,任意类型. 可以通过as!转成需要的类型,再赋值(不可以直接赋值) class Person: NSObject { var name : String var age : Int // 自定义构造函数,会覆盖init()函数 init(dict : [String : NSObject]) { name = dict["name"] as! String age = dict["age"] as! Int } } // 创建一个Person对象 let dict = ["name" : "why", "age" : 18] let p = Person(dict: dict) 字典转模型(利用KVC转化) 利用KVC字典转模型会更加方便 注意: KVC并不能保证会给所有的属性赋值 因此属性需要有默认值 基本数据类型默认值设置为0 对象或者结构体类型定义为可选类型即可(可选类型没有赋值前为nil) class Person: NSObject { // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值 var name : String? // 基本数据类型不能是可选类型,否则KVC无法转化 var age : Int = 0 // 自定义构造函数,会覆盖init()函数 init(dict : [String : NSObject]) { // 必须先初始化对象 super.init() // 调用对象的KVC方法字典转模型 setValuesForKeysWithDictionary(dict) } } // 创建一个Person对象 let dict = ["name" : "why", "age" : 18] let p = Person(dict: dict)
12、类的析构函数
析构函数 Swift 会自动释放不再需要的实例以释放资源 Swift 通过自动引用计数（ARC）处理实例的内存管理 当引用计数为0时,系统会自动调用析构函数(不可以手动调用) 通常在析构函数中释放一些资源(如移除通知等操作) 析构函数的写法 deinit { // 执行析构过程 } 示例练习 class Person { var name : String var age : Int init(name : String, age : Int) { self.name = name self.age = age } deinit { print("Person-deinit") } } var p : Person? = Person(name: "why", age: 18) p = nil
13、循环引用解决
工作机制 Swift和OC一样,采用自动引用计数来管理内容 当有一个强引用指向某一个动向时,该对象的引用计数会自动+1 当该强引用消失时,引用计数会自动-1 当引用计数为0时,该对象会被销毁 循环引用 在通常情况下,ARC是会自动帮助我们管理内存的 但是在开发中我们经常会出现循环引用的问题,比如下面的示例 Student对Book对象有一个强引用 而Book对Student有一个强引用 在两个对象都指向nil时,依然不会被销毁,就形成了循环引用 // 1.创建类 class Student { var book : Book? deinit { print("Student -- deinit") } } class Book { var owner : Student? deinit { print("Book -- deinit") } } // 2.创建对象 var stu : Student? = Student() var book : Book? = Book() // 3.相互引用 stu?.book = book book?.owner = stu // 4.对象置nil stu = nil book = nil 解决方案 swift提供了两种解决方案 weak : 和OC中的__weak一样是一个弱引用.当指向的对象销毁时,会自动将指针指向nil unowned : 和OC中的__unsafe_unretained.当对象销毁时依然指向原来的位置(容易引起野指针) // 1.创建类 class Student { weak var book : Book? // unowned var book : Book = Book() deinit { print("Student -- deinit") } } class Book { var owner : Student? deinit { print("Book -- deinit") } } // 2.创建对象 var stu : Student? = Student() var book : Book? = Book() // 3.相互引用 stu?.book = book! book?.owner = stu // 4.对象置nil stu = nil book = nil
14.可选链的使用
可选连的概念 它的可选性体现于请求或调用的目标当前可能为空（nil） 如果可选的目标有值，那么调用就会成功； 如果选择的目标为空（nil），则这种调用将返回空（nil） 多次调用被链接在一起形成一个链，如果任何一个节点为空（nil）将导致整个链失效。 可选链的使用 在可选类型后面放一个问号，可以定义一个可选链。 这一点很像在可选值后面放一个叹号来强制拆得其封包内的值 它们的主要的区别在于当可选值为空时可选链即刻失败 然而一般的强制解析将会引发运行时错误。 因为可选链的结果可能为nil,可能有值.因此它的返回值是一个可选类型. 可以通过判断返回是否有值来判断是否调用成功 有值,说明调用成功 为nil,说明调用失败 可选链的示例 从可选链中取值 示例描述: 人(Person)有一个狗(Dog),狗(Dog)有一个玩具(Toy),玩具有价格(price) 使用代码描述上述信息 // 1.定义类 class Person { var name : String var dog : Dog? init(name : String) { self.name = name } } class Dog { var color : UIColor var toy : Toy? init(color : UIColor) { self.color = color } func runing() { print("跑起来") } } class Toy { var price : Double = 0.0 } // 2.创建对象,并且设置对象之间的关系 // 2.1.创建对象 let person = Person(name: "小明") let dog = Dog(color: UIColor.yellow) let toy = Toy() toy.price = 100.0 // 2.2.设置对象之间的关系 person.dog = dog dog.toy = toy 需求:获取小明的大黄宠物的玩具价格 取出的值为可选类型,因为可选链中有一个可选类型为nil,则返回nil 因此结果可能有值,可能为nil.因此是一个可选类型 let price = person.dog?.toy?.price print(price) // Optional(100.0)\n 需求:给小明的大黄一个新的玩具 相当于给可选类型赋值 person.dog?.toy = Toy() 需求:让小明的狗跑起来 如果可选类型有值,则会执行该方法 如果可选类型为nil,则该方法不会执行 person.dog?.runing()
15、协议的使用
协议的格式 协议的定义方式与类，结构体，枚举的定义都非常相似 protocol SomeProtocol { // 协议方法 } 遵守协议的格式 class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { // 类的内容 // 实现协议中的方法 } 协议的基本使用 定义协议和遵守协议 // 1.定义协议 protocol SportProtocol { func playBasketball() func playFootball() } // 2.遵守协议 // 注意:默认情况下在swift中所有的协议方法都是必须实现的,如果不实现,则编译器会报错 class Person : SportProtocol { var name : String? var age : Int = 0 // 实现协议中的方法 func playBasketball() { print("人在打篮球") } func playFootball() { print("人在踢足球") } } 协议之间的继承 protocol CrazySportProtocol { func jumping() } protocol SportProtocol : CrazySportProtocol { func playBasketball() func playFootball() } 代理设计模式 协议继承用于代理设计模式 protocol BuyTicketProtocol { func buyTicket() } class Person { // 1.定义协议属性 var delegate : BuyTicketProtocol // 2.自定义构造函数 init (delegate : BuyTicketProtocol) { self.delegate = delegate } // 3.行为 func goToBeijing() { delegate.buyTicket() } } class HuangNiu: BuyTicketProtocol { func buyTicket() { print("买了一张火车票") } } let p = Person(delegate: HuangNiu()) p.goToBeijing() 协议中方法的可选 // 1.定义协议 @objc protocol SportProtocol { func playBasketball() optional func playFootball() } // 2.遵守协议 class Person : SportProtocol { var name : String? var age : Int = 0 // 实现协议中的方法 @objc func playBasketball() { print("人在打篮球") } }
三、
1.闭包的使用
闭包的介绍 闭包和OC中的block非常相似 OC中的block是匿名的函数 Swift中的闭包是一个特殊的函数 block和闭包都经常用于回调 注意:闭包和block一样,第一次使用时可能不习惯它的语法,可以先按照使用简单的闭包,随着学习的深入,慢慢掌握其灵活的运用方法. 闭包的使用 block的用法回顾 定义网络请求的类 @interface HttpTool : NSObject - (void)loadRequest:(void (^)())callBackBlock; @end @implementation HttpTool - (void)loadRequest:(void (^)())callBackBlock { dispatch_async(dispatch_get_global_queue(0, 0), ^{ NSLog(@"加载网络数据:%@", [NSThread currentThread]); dispatch_async(dispatch_get_main_queue(), ^{ callBackBlock(); }); }); } @end 进行网络请求,请求到数据后利用block进行回调 - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event { [self.httpTool loadRequest:^{ NSLog(@"主线程中,将数据回调.%@", [NSThread currentThread]); }]; } block写法总结: block的写法: 类型: 返回值(^block的名称)(block的参数) 值: ^(参数列表) { // 执行的代码 }; 使用闭包代替block 定义网络请求的类 class HttpTools: NSObject { func requestData(finishedCallback : @escaping (_ jsonData : String, _ age : Int) -> ()) { // 1.创建全局队列, 发送异步请求 DispatchQueue.global().async { print("发送网络请求:\(Thread.current)") DispatchQueue.main.async { print("回调主线程:\(Thread.current)") finishedCallback("123", 30) } } } } 进行网络请求,请求到数据后利用闭包进行回调 override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) { httpTools.requestData { (jsonData :String, age : Int) in print("回到控制器,获取到数据") } } 闭包写法总结: 闭包的写法: 类型:(形参列表)->(返回值) 技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值 值: { (形参) -> 返回值类型 in // 执行代码 } 尾随闭包写法: 如果闭包是函数的最后一个参数,则可以将闭包写在()后面 如果函数只有一个参数,并且这个参数是闭包,那么()可以不写 httpTool.loadRequest() { print("回到主线程", NSThread.currentThread()); } // 开发中建议该写法 httpTool.loadRequest { print("回到主线程", NSThread.currentThread()); } 闭包的循环引用 如果在HttpTool中有对闭包进行强引用,则会形成循环引用 补充:在Swift中检测一个对象是否销毁,可以实现对象的deinit函数 // 析构函数(相当于OC中dealloc方法) deinit { print("ViewController----deinit") } 循环引用的(实现) 该实现是为了产生循环引用,而产生的循环引用 class HttpTools: NSObject { var finishedCallback : ((_ jsonData : String, _ age : Int) -> ())? func requestData(finishedCallback : @escaping (_ jsonData : String, _ age : Int) -> ()) { self.finishedCallback = finishedCallback // 1.创建全局队列, 发送异步请求 DispatchQueue.global().async { print("发送网络请求:\(Thread.current)") DispatchQueue.main.async { print("回调主线程:\(Thread.current)") finishedCallback("123", 30) } } } } swift中解决循环引用的方式 方案一: 使用weak,对当前控制器使用弱引用 但是因为self可能有值也可能没有值,因此weakSelf是一个可选类型,在真正使用时可以对其强制解包(该处强制解包没有问题,因为控制器一定存在,否则无法调用所在函数) // 解决方案一: weak var weakSelf = self httpTool.loadData { print("加载数据完成,更新界面:", NSThread.currentThread()) weakSelf!.view.backgroundColor = UIColor.redColor() } 方案二: 和方案一类型,只是书写方式更加简单 可以写在闭包中,并且在闭包中用到的self都是弱引用 httpTool.loadData {[weak self] () -> () in print("加载数据完成,更新界面:", NSThread.currentThread()) self!.view.backgroundColor = UIColor.redColor() } 方案三:(常用) 使用关键字unowned 从行为上来说 unowned 更像OC中的 unsafe_unretained unowned 表示:即使它原来引用的对象被释放了，仍然会保持对被已经释放了的对象的一个 “无效的” 引用，它不能是 Optional 值，也不会被指向 nil httpTool.loadData {[unowned self] () -> () in print("加载数据完成,更新界面:", NSThread.currentThread()) self.view.backgroundColor = UIColor.redColor() }
2.懒加载的使用
懒加载的介绍 swift中也有懒加载的方式 (苹果的设计思想:希望所有的对象在使用时才真正加载到内存中) 和OC不同的是swift有专门的关键字来实现懒加载 lazy关键字可以用于定义某一个属性懒加载 懒加载的使用 格式 lazy var 变量: 类型 = { 创建变量代码 }() 懒加载的使用 // 懒加载的本质是,在第一次使用的时候执行闭包,将闭包的返回值赋值给属性 // lazy的作用是只会赋值一次 lazy var array : [String] = { () -> [String] in return ["why", "lmj", "lnj"] }()
3.访问权限
swift中的访问权限 Swift 中的访问控制模型基于模块和源文件这两个概念 internal : 在本模块中都可以进行访问 fileprivate : 在当前源文件中可以访 private : 在当前class中可以访问(extension中也不可以访问) open : 在其他模块中可以访问
57
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
