第三篇、Swift基础学习

1.常量与变量

什么是常量和变量

在Swift中规定：在定义一个标识符时必须明确说明该标识符是一个常量还是变量
使用let来定义常量，定义之后不可以修改
使用var来定义变量，定义之后可以修改
变量的基本使用

import UIKit
let a : Int =
// 错误写法,当一个标识符定义为常量时是不可以修改的
// a = 20
var b : Int =
// 因为b定义为变量,因此是可以修改的
b =
常量和变量的使用注意:

注意:
在真实使用过程中,建议先定义常量,如果需要修改再修改为变量(更加安全)
是指向的对象不可以再进行修改.但是可以通过指针获得对象后,修改对象内部的属性
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: , y: , width: , height: )
// Swift中调用方法，统一使用点语法
view.backgroundColor = UIColor.red
创建对象补充

创建UIView对象，并且在UIView中添加UIButton
import UIKit
// 1.创建UIView对象
// OC : [[UIView alloc] initWithFrame:CGRect]
let viewRect = CGRect(x: , y: , width: , height: )
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: , y: , width: , height: )
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 =
// 定义一个Double类型的常量n,并且赋值为3.14
let n : Double = 3.14
Swift中的类型推导

Swift是强类型的语言
Swift中任何一个标识符都有明确的类型
注意:
如果定义一个标识符时有直接进行赋值,那么标识符后面的类型可以省略.
因为Swift有类型推导,会自动根据后面的赋值来决定前面的标识符的数据类型
可以通过option+鼠标左键来查看变量的数据类型

/*
 类型推导
    1> Swift中任何一个标识符都有自己明确的类型
    2> 如果定义一个标识符时有直接给该标识符进行赋值，那么标识符后面的类型可以省略
    3> 编译器会自动根据后面赋值的类型，推导出前面标识符的类型
    4> 可以根据option + 鼠标左键，查看标识符的类型
 */
// m是Int类型
let m =
// 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 =
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 =
// 错误写法:
//if a {
//    print("a")
//}
// 正确写法
if a >  {
    print(a)
}
// 演练二:
let score =
if score <  {
    print("不及格")
} else if score <=  {
    print("及格")
} else if score <=  {
    print("良好")
} else if score <=  {
    print("优秀")
} else {
    print("完美")
}
二.guard的使用

guard是Swift2.0新增的语法
它与if语句非常类似，它设计的目的是提高程序的可读性
guard语句必须带有else语句，它的语法如下：
当条件表达式为true时候跳过else语句中的内容，执行语句组内容
条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw
guard 条件表达式 else {
    // 条换语句
    break
}
语句组
例子
var age =
func online(age : Int) -> Void {
    guard age >=  else {
        print("回家去")
        return
    }
    print("可以上网")
}
online(age)
三.switch分支

switch的介绍

Switch作为选择结构中必不可少的语句也被加入到了Swift中
只要有过编程经验的人对Switch语句都不会感到陌生
但苹果对Switch进行了大大的增强，使其拥有其他语言中没有的特性
switch的简单使用

基本用法和OC用法一致
不同之处:
switch后可以不跟()
case后可以不跟break(默认会有break)
例子:
let sex =
switch sex {
case  :
    print("男")
case  :
    print("女")
default :
    print("其他")
}
简单使用补充:
一个case判断中,可以判断多个值
多个值以,隔开
let sex =
switch sex {
case , :
    print("正常人")
default:
    print("其他")
}
简单使用补充:
如果希望出现之前的case穿透,则可以使用关键字fallthrough
let sex =
switch sex {
case :
    fallthrough
case :
    print("正常人")
default:
    print("其他")
}
switch支持区间判断

什么是区间?
通常我们指的是数字区间:~,~
swift中的区间常见有两种
半开半闭区间:..< 表示:~,不包括10
闭区间:… 表示:~
let score =
switch score {
case ..<:
    print("不及格")
case ..<:
    print("几个")
case ..<:
    print("良好")
case ..<:
    print("优秀")
default:
    print("满分")
}

4.循环使用

循环的介绍

在开发中经常会需要循环
常见的循环有:for/while/do while.
这里我们只介绍for/while,因为for/while最常见
for循环的写法

区间for循环
for i in ..< {
    print(i)
}
for i in ... {
    print(i)
}
特殊写法
如果在for循环中不需要用到下标i
for _ in ..< {
    print("hello")
}
while和do while循环

while循环
while的判断句必须有正确的真假,没有非0即真
while后面的()可以省略
var a =
while a <  {
    a++
}
do while循环
使用repeat关键字来代替了do
let b =
repeat {
    print(b)
    b++
} while b < 

二、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 =
let info = "my name is \(name), age is \(age)"
字符串的格式化
比如时间::
let min =
let second =
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: )
let footer1 = (urlString as NSString).substring(from: )
let range1 = NSRange(location: , length: )
let middle1 = (urlString as NSString).substring(with: range1)
swift截取方式
let urlString = "www.520it.com"
let headerIndex = urlString.index(urlString.startIndex, offsetBy: )
let header2 = urlString.substring(to: headerIndex)
let footerIndex = urlString.index(urlString.endIndex, offsetBy: -)
let footer2 = urlString.substring(from: footerIndex)
let startIndex = urlString.index(urlString.startIndex, offsetBy: )
let endIndex = urlString.index(urlString.startIndex, offsetBy: )
let range2 = Range(startIndex..<endIndex)
let middle2 = urlString.substring(with: range2)

2.数组的使用

数组的介绍

数组（Array）是一串有序的由相同类型元素构成的集合
数组中的集合元素是有序的，可以重复出现
Swift中的数组
swift数组类型是Array，是一个泛型集合
数组的初始化

数组分成:可变数组和不可变数组

使用let修饰的数组是不可变数组
使用var修饰的数组是可变数组
定义不可变数组

let array : [Any] = ["why", , 1.88]
定义可变数组
var arrayM = [Any]()
对数组的基本操作

// 添加数据
array.append("yz")
// 删除元素
array.removeFirst()
// 修改元素
array[] = "why"
// 取值
array[]
数组的遍历

// 遍历数组
for i in ..<array.count {
    print(array<i>)
}
// forin方式
for item in array {
    print(item)
}
// 设置遍历的区间
for item in array[..<] {
    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 = [, , "why"]
var array4 = ["yz", ]
array3 + array4

3.字典的使用

字典的介绍

字典允许按照某个键来访问元素
字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合
键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的
Swift中的字典
Swift字典类型是Dictionary，也是一个泛型集合
字典的初始化

Swift中的可变和不可变字典
使用let修饰的数组是不可变字典
使用var修饰的数组是可变字典
// 定义一个可变字典
var dict1 : [String : Any] = [String : Any]()
// 定义一个不可变字典
let dict2 : [String : Any] = ["name" : "why", "age" : ]
字典的基本操作

// 添加数据
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" : ]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

4.元组的使用

元组的介绍

元组是Swift中特有的,OC中并没有相关类型
它是什么呢?
它是一种数据结构，在数学中应用广泛
类似于数组或者字典
可以用于定义一组数据
组成元组类型的数据可以称为“元素”
元组的定义

元组的常见写法
// 使用元组描述一个人的信息
("", "张三", , )
// 给元素加上元素名称,之后可以通过元素名称访问元素
(id:"", name:"张三", english_score:, chinese_score:)
元组的简单使用

用元组来描述一个HTTP的错误信息
// 元组:HTTP错误
// let array = [404, "Not Found"]
// 写法一:
let error = (, "Not Found")
print(error.)
print(error.)
// 写法二:
let error = (errorCode : , errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)
// 写法三:
let (errorCode, errorIno) = (, "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 =
// 正确写法:
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 = ""
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" : ]
dict["name"]
dict["height"]

6.类型转化（as）

常见的类型转化符号

as : 将实例转成某一种类型
例子

// 1.定义数组
let array : [AnyObject] = [, "why", 1.88]
// 2.取出第二个元素
let objc = array[]
// 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: , num2: )
函数的使用注意

注意一: 外部参数和内部参数
在函数内部可以看到的参数,就是内部参数
在函数外面可以看到的参数,就是外部参数
默认所有的参数都是外部参数和内部参数
如果不想要外部参数,可以在参数名称前加_
// 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: , cba: )
// sum(20, 30)
注意二: 可变参数
swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数
它们必须具有相同的类型
我们可以通过在参数类型名后面加入（…）的方式来指示这是可变参数
// 2.可变参数
func sum(nums : Int...) -> Int {
    var total =
    for num in nums {
        total += num
    }
    return total
}
sum(nums: , , , )
func myPrint(_ items : Any...) {
    var strM : String = "\(items[0])"
    for i in ..<items.count {
        strM = strM + " " + "\(items<i>)"
    }
    print(strM)
}
print(, , )
myPrint(, , )
注意三: 默认参数
某些情况,如果没有传入具体的参数,可以使用默认参数
func makeCoffee(coffeeName : String = "雀巢") {
    print("制作了一杯爱心\(coffeeName)咖啡")
}
makeCoffee(coffeeName: "拿铁")
makeCoffee(coffeeName: "摩卡")
makeCoffee()
注意四: 引用类型(指针的传递)
默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
必须是变量,因为需要在内部改变其值
Swift提供的inout关键字就可以实现
对比下列两个函数
// 4.指针参数
var m =
var n =
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，，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 =
  case South =
  case East =
  case West =
}
enum Planet {
  case Mercury = , Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}
// 2.枚举类型的使用
let p = Planet(rawValue: )
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: , y: )
结构体的增强

扩充构造函数
默认情况下创建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: , y: )
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 =
    var name : String?
    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0
}
// 创建学生对象
let stu = Student()
// 给存储属性赋值
stu.age =
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 =
    var name : String?
    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0
    // 计算属性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) /
        }
        // 没有意义,因为之后获取值时依然是计算得到的
        // newValue是系统分配的变量名,内部存储着新值
        set {
            self.averageScore = newValue
        }
    }
}
// 获取计算属性的值
print(stu.averageScore)
类属性

类属性是与类相关联的，而不是与类的实例相关联
所有的类和实例都共有一份类属性.因此在某一处修改之后,该类属性就会被修改
类属性的设置和修改,需要通过类来完成
下面是类属性的写法
类属性使用static来修饰
courseCount是类属性,用来记录学生有多少门课程
class Student : NSObject {
    // 定义属性
    // 存储属性
    var age : Int =
    var name : String?
    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0
    // 计算属性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) /
        }
        // 没有意义.newValue是系统分配的变量名,内部存储着新值
        set {
            self.averageScore = newValue
        }
    }
    // 类属性
    static var corseCount : Int =
}
// 设置类属性的值
Student.corseCount =
// 取出类属性的值
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 =
    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 =
    }
}
// 创建一个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: )
字典转模型(初始化时传入字典)

真实创建对象时,更多的是将字典转成模型
注意:
去字典中取出的是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" : ]
let p = Person(dict: dict)
字典转模型(利用KVC转化)

利用KVC字典转模型会更加方便
注意:
KVC并不能保证会给所有的属性赋值
因此属性需要有默认值
基本数据类型默认值设置为0
对象或者结构体类型定义为可选类型即可(可选类型没有赋值前为nil)
class Person: NSObject {
    // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值
    var name : String?
    // 基本数据类型不能是可选类型,否则KVC无法转化
    var age : Int =
    // 自定义构造函数,会覆盖init()函数
    init(dict : [String : NSObject]) {
        // 必须先初始化对象
        super.init()
        // 调用对象的KVC方法字典转模型
        setValuesForKeysWithDictionary(dict)
    }
}
// 创建一个Person对象
let dict = ["name" : "why", "age" : ]
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: )
p = nil

13、循环引用解决

工作机制

Swift和OC一样,采用自动引用计数来管理内容
当有一个强引用指向某一个动向时,该对象的引用计数会自动+
当该强引用消失时,引用计数会自动-
当引用计数为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 =
    // 实现协议中的方法
    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 =
    // 实现协议中的方法
    @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(, ), ^{
        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("", )
            }
        }
    }
}
进行网络请求,请求到数据后利用闭包进行回调
    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("", )
            }
        }
    }
}
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 : 在其他模块中可以访问