Swift4.2语言快速入门大学霸内部资料

Swift4.2语言快速入门大学霸内部资料

介绍：本教程详细讲解Swift4.2语言的入门知识，并针对每一个知识点配套相应实例，帮助读者可以快速学习和掌握Swift4.2语言。

试读下载链接：https://pan.baidu.com/s/1O651eIxYv5ACoxpEGl5L0Q 提取码: hw4x

更新说明：v6.0:（1）Xcode更新到10.0。（2）Swift更新到4.2。v5.0:（1）Swift语法更新到4.0。（2）开发环境更新到Mac OS 10.12.6+Xcode 9.0。

学习建议：本教程着重讲解Swift基础语法，如果要学习深入的语法内容可以阅读教程：Swift数据处理基础篇。如果要学习APP开发的相关知识，建议阅读教程：iOS应用开发基础教程。

注意：如需购买教程或者有疑问，可以联系 QQ:2186937435、1516986659

声明：
买教程送邮件答疑
教程版权归大学霸所有
教程为彩色
由于教程有水印，影响二次销售，不接受退款
为防盗版，教程每页都会添加水印，水印默认为购买者的账号名+电话
购买时，请QQ联系，确定收货地址、付款方式等。

目录

第1章 编写第一个Swift程序  1

1.1 初识Swift     1

1.1.1 Swift的诞生     1

1.1.2 Swift的特点与不足  1

1.1.3 Xcode和Swift语言的对应     2

1.1.4 Swift旧版本的语言转换为Swift 4.2语言     3

1.2 搭建开发环境      3

1.2.1 安装Xcode 10.0       3

1.2.2 安装组件   3

1.2.3 更新组件和文档       4

1.3 编写第一个程序   6

1.3.1 创建项目   6

1.3.2 Xcode 10.0界面介绍       9

1.3.3 编译和运行       10

1.3.4 编写代码   11

1.3.5 生成可执行文件       12

1.4 Swift代码分析     13

1.4.1 代码的构成       14

1.4.2 标识符       14

1.4.3 关键字       15

1.4.4 注释   15

1.4.5 文件构成   16

1.5 使用帮助文档      16

第2章 数据类型       19

2.1 常量变量      19

2.1.1 常量   19

2.1.2 变量   19

2.1.3 为声明的变量和常量指定数据类型       20

2.2 简单的数据类型   21

2.2.1 整数（Integer）       21

2.2.2 整型   22

2.2.3 浮点类型   23

2.2.4 字符类型/字符串类型      24

2.2.5 布尔类型   24

2.2.6 可选类型   25

2.3字面值     25

2.3.1 整型字面值       26

2.3.2 浮点类型的字面值   26

2.3.3 字符型字面值   27

2.3.4 字符串字面值   27

2.3.5 布尔类型的字面值   28

2.4 高级数据类型——元组      28

2.5 类型别名      30

第3章 语句和表达式       31

3.1 语句      31

3.2 运算符与表达式   31

3.2.1 常用术语——元       31

3.2.2 赋值运算符和表达式       32

3.2.3 算术运算符和表达式       32

3.2.4 取余运算符和表达式       34

3.2.5 一元减运算符   35

3.2.6 一元加运算符   35

3.2.7 位运算符   36

3.2.8 溢出运算符       41

3.2.9 比较运算符和表达式       43

3.2.10 三元条件运算符     44

3.2.11 逻辑运算符和表达式     45

3.2.12 范围运算符     47

3.2.13 复合赋值运算符和表达式     48

3.2.14 字节计算  49

3.2.15 空合运算符     49

3.2.16 强制解析  50

3.3 类型转换      51

3.3.1 整数的转换       51

3.3.2 整数和浮点数的转换       51

第4章 字符串    53

4.1 字符串的初始化   53

4.1.1 字符串的种类   53

4.1.2 初始化空的字符串   53

4.1.3 使用字符串初始化字符串       54

4.1.4 遍历字符   54

4.2 Unicode编码 55

4.2.1 Unicode术语     55

4.2.2 Unicode字符串 55

4.2.3 UTF-8编码       56

4.2.4 UTF-16编码     56

4.2.5 UTF标量   57

4.3 Swift 4.0新增——多行文字的字符串      57

第5章 集合类型       59

5.1 数组      59

5.1.1 数组字面量       59

5.1.2 数组的定义       59

5.1.3 数组的初始化   60

5.2 字典      61

5.2.1 字典字面量       61

5.2.2 字典的定义       62

5.2.3 字典的初始化   62

5.2.4 Swift 4.0新增——改进了字典的功能   63

5.3 集合      64

5.3.1 集合的声明       64

5.3.2 集合的初始化   64

5.4 Swift 4.0新增——String变成了集合类型       65

5.5 可变的集合类型   65

第6章 程序控制结构       66

6.1 顺序结构      66

6.1.1 程序的执行流程       66

6.1.2 代码调试   67

6.2 选择结构——if语句   68

6.2.1 if语句       68

6.2.2 if…else语句      69

6.2.3 if…else if语句   71

6.3 选择结构——switch语句   72

6.3.1 switch语句基本形式 72

6.3.2 规则1：相同的常量或常量表达式 75

6.3.3 规则2：可执行的语句不能为空    75

6.3.4 规则3：多条件组合 75

6.3.5 规则4：范围匹配    76

6.3.6 规则5：使用元组    76

6.3.7 规则6：数值绑定    77

6.3.8 规则7：使用where关键字     78

6.4 循环结构——for in语句    79

6.5 循环结构——while语句     81

6.5.1 while循环  81

6.5.2 repeat while循环      82

6.6 跳转语句      83

6.6.1 continue语句     83

6.6.2 break语句  84

6.6.3 fallthrough语句 85

6.6.4 使用标签语句   85

6.7 Swift 2.0新增——guard语句    87

第7章 函数和闭包    89

7.1 函数介绍      89

7.2 使用无参函数      90

7.2.1 无参函数的声明定义       90

7.2.2 无参函数的调用       91

7.2.3 空函数       92

7.3 使用有参函数      92

7.3.1 有参函数的声明定义       92

7.3.2 有参函数的调用       93

7.3.3 参数的注意事项       93

7.4 函数参数的特殊情况   94

7.4.1 函数参数名       94

7.4.2 外部参数名       95

7.4.3 设定参数默认值       96

7.4.4 为外部参数设置默认值   97

7.4.5 可变参数   97

7.4.6 输入-输出参数  98

7.5 函数的返回值      99

7.5.1 具有一个返回值的函数   100

7.5.2 具有多个返回值的函数   100

7.5.3 无返回值   101

7.6 函数类型      102

7.6.1 使用函数类型   102

7.6.2 使用函数类型作为参数类型   103

7.6.3 使用函数类型作为返回值类型       103

7.7 标准函数      104

7.8 函数嵌套调用形式      105

7.8.1 嵌套调用基本形式   105

7.8.2 递归调用   106

7.9 闭包      108

7.9.1 闭包表达式       108

7.9.2 使用闭包表达式的注意事项   111

7.9.3 Trailing闭包     112

7.9.4 捕获值       113

7.10 Swift 2.1——协变性和逆变性  114

第8章 类    115

8.1 类与对象      115

8.1.1 类的组成   115

8.1.2 创建类       115

8.1.3 实例化对象       116

8.2 属性      116

8.2.1 存储属性   116

8.2.2 计算属性   121

8.2.3 类型属性   125

8.2.4 属性监视器       127

8.3 方法      130

8.3.1 实例方法   130

8.3.2 类型方法   133

8.3.3 存储属性、局部变量和全局变量的区别       136

8.3.4 局部变量和存储属性同名的解决方法——self属性     138

8.4 下标脚本      138

8.4.1 定义下标脚本   138

8.4.2 调用下标脚本   139

8.4.3 使用下标脚本   139

8.5 类的嵌套      142

8.5.1 直接嵌套   142

8.5.2 多次嵌套   144

8.6 可选链接      146

8.6.1 可选链接的实现方式       146

8.6.2 通过可选链接调用属性、下标脚本、方法   147

8.6.3 连接多个链接   149

第9章 继承       150

9.1 为什么使用继承   150

9.1.1 减少代码量       150

9.1.2 扩展功能   151

9.2 继承的实现   153

9.2.1   继承的定义     153

9.2.2 属性的继承       153

9.2.3 下标脚本的继承       154

9.2.4 方法的继承       155

9.3 继承的特点   156

9.3.1 多层继承   156

9.3.2 不可删除   157

9.4 重写      158

9.4.1 重写属性   158

9.4.2 重写下标脚本   160

9.4.3 重写方法   161

9.4.4 重写的注意事项       163

9.4.5 访问父类成员   163

9.4.6 阻止重写   167

9.5 类型检查      169

9.5.1 类型检查——is 169

9.5.2 类型检查——as 171

9.5.3 AnyObject和Any的类型检查 173

第10章 枚举类型      176

10.1 枚举类型的组成 176

10.2 定义枚举类型    176

10.2.1 任意类型的枚举类型     177

10.2.2 指定数据类型的枚举类型     177

10.3 定义枚举类型的成员 177

10.3.1 定义任意类型的枚举成员     178

10.3.2 定义指定数据类型的枚举类型成员     179

10.3.3 注意事项  180

10.4 实例化枚举类型的对象    180

10.5 访问枚举类型中成员的原始值 181

10.5.1 通过成员访问原始值     181

10.5.2 通过原始值获取成员     183

10.6 枚举成员与switch匹配    184

10.7 相关值 185

10.8 定义枚举类型的属性 187

10.8.1 计算属性  187

10.8.2 类型属性  187

10.8.3 属性监视器     188

10.9 定义枚举类型的下标脚本 189

10.10 定义枚举类型的方法      190

10.10.1 实例方法       190

10.10.2 类型方法       191

10.11 枚举类型的应用      192

10.11.1 为常量/变量赋值  192

10.11.2 作为函数的参数   193

10.12 枚举类型嵌套   193

10.12.1 直接嵌套       194

10.12.2 多次嵌套       195

10.13 Swift 2.1——枚举类型特点   196

第11章 结构      197

11.1 结构的定义和实例化 197

11.1.1 结构的构成     197

11.1.2 定义结构  197

11.1.3 实例化对象     198

11.2 定义结构的属性 198

11.2.1 存储属性  198

11.2.2 计算属性  199

11.2.3 类型属性  200

11.2.4 添加属性监视器     201

11.2.5 初始化实例对象     201

11.3   定义结构的下标脚本      203

11.4 定义结构的方法 204

11.4.1 实例方法  204

11.4.2 类型方法  205

11.5 结构嵌套    206

11.5.1 直接嵌套  206

11.5.2 多次嵌套  207

11.6 类、枚举类型、结构的区别    209

11.7 类、枚举、结构的嵌套    209

11.7.1 枚举使用在类中     209

11.7.2 枚举使用在结构中  210

11.7.3 类使用在结构中     211

11.8 Swift 2.1——结构特性     212

第12章 构造方法和析构方法  213

12.1 值类型的构造器 213

12.1.1 默认构造器     213

12.1.2 自定义构造器  214

12.1.3 构造器代理     217

12.2 类的构造器 222

12.2.1 默认构造器     222

12.2.2 自定义构造器  222

12.2.3 构造器代理     227

12.2.4 构造器的继承和重载     228

12.2.5 必要构造器     234

12.3 可失败构造器    235

12.3.1 定义可失败构造器  235

12.3.2 枚举类型的可失败构造器     236

12.3.3 类的可失败构造器  237

12.3.4 构造失败的传递     237

12.3.5 重写一个可失败构造器  239

12.3.6 可失败构造器init!  240

12.4 构造器的特殊情况    240

12.4.1 可选类型  240

12.4.2 修改常量属性  241

12.5 类的构造    242

12.6 设置默认值 243

12.6.1 在定义时直接赋值  244

12.6.2 在构造器中赋值     244

12.6.3 使用闭包设置属性的默认值  244

12.6.4 使用函数设置默认值     246

12.7 析构方法    246

12.7.1 理解析构  246

12.7.2 析构方法的定义     247

12.7.3 使用析构方法  247

12.7.4 构造方法和析构方法的区别  248

第13章 扩展和协议  249

13.1 扩展    249

13.1.1 扩展的定义     249

13.1.2 扩展属性  249

13.1.3 扩展构造器     252

13.1.4 扩展方法  254

13.1.5 扩展下标脚本  256

13.1.6 扩展嵌套类型  257

13.2 协议    258

13.2.1 协议的定义     258

13.2.2 协议的实现     258

13.2.3 协议的成员声明——属性     260

13.2.4 协议的成员声明——方法     262

13.2.5 协议的成员声明——可变方法     264

13.3 可选协议    265

13.3.1 定义可选协议  267

13.3.2 声明可选成员  267

13.3.3 调用可选协议  268

13.4 使用协议类型    270

13.4.1 协议类型作为常量、变量等的数据类型     270

13.4.2 协议类型的返回值或参数     271

13.4.3 协议类型作为集合的元素类型     271

13.5 在扩展中使用协议    272

13.5.1 在扩展中实现协议  272

13.5.2 定义协议成员  273

13.5.3 扩展协议声明  273

13.6 协议的继承 274

13.7 协议组合    275

13.8 检查协议的一致性    276

13.9 委托    277

第14章 自动引用计数（ARC）      281

14.1 自动引用计数的工作机制 281

14.2 循环强引用的产生    283

14.2.1 类实例之间的循环强引用     283

14.2.2  闭包引起的循环强引用  285

14.3 循环强引用的解决方法    286

14.3.1 解决类实例之间的循环强引用     286

14.3.2 解决闭包引起的循环强引用  291

第15章 运算符重载  294

15.1 为什么使用运算符重载    294

15.2 算术运算符的重载    294

15.3 一元减/加运算符的重载   296

15.3.1 一元减运算符的重载     296

15.3.2 一元加运算符的重载     296

15.4 复合赋值运算符的重载    297

15.5 比较运算符的重载    299

15.5.1 “==”相等运算符的重载     299

15.5.2 “!=”不相等运算符的重载  300

15.5.3 其他比较运算符的重载  300

15.6 自定义运算符的重载 301

15.6.1 前置自定义运算符的重载     301

15.6.2 中置自定义运算符的重载     302

15.6.3 后置自定义运算符的重载     303

15.6.4 自定义运算符的优先级和结合性  305

15.7 注意事项    310

15.7.1 重载后运算符的优先级  311

15.7.2 不可以重载的运算符     312

第16章 泛型与错误处理机制  313

16.1 为什么使用泛型 313

16.2 泛型函数    314

16.3 泛型类型    315

16.3.1 泛型枚举  315

16.3.2 泛型结构  315

16.3.3 泛型类     317

16.4 泛型类的层次结构    318

16.4.1 使用泛型基类  318

16.4.2 使用泛型派生类     319

16.5 具有多个类型参数的泛型 320

16.6 类型约束    320

16.7 关联类型    321

16.7.1 定义关联类型  321

16.7.2 扩展已存在类型为关联类型  323

16.7.3 约束关联类型  325

16.8 Swift 2.0新增——新的错误处理机制    327

16.8.1 抛出错误  327

16.8.2 捕获错误和处理错误     328

16.8.3 清理动作  329

16.9 Swift 2.0新增——可用性检查 329

第17章  Swift 2.2新增内容      331

17.1 元组对象的比较操作 331

17.2 编译期Swift版本检查      331

17.3 引用Objective-C的选择器       332

17.4 重命名debug标识符 332