1、属性
Swift 中属性可以分为以下几种：
实例属性（Instance Property）：只能通过实例去访问。
存储实例属性（Stored Instance Property）：存储在实例的内存中，每个实例都有1份。
计算实例属性（Computed Instance Property）
类型属性（Type Property）：只能通过类型去访问。
存储类型属性（Stored Type Property）：整个程序运行过程中，就只有1份内存（类似于全局变量）。
计算类型属性（Computed Type Property）
1、实例属性
Swift 中跟实例相关的属性可以分为2大类存储属性和计算属性。
struct Circle {
// 存储属性
var radius: Double
// 计算属性
var diameter: Double {
set {
radius = newValue / 2
}
get {
radius * 2
}
}
}
var circle = Circle(radius: 5)
print(circle.radius) // 5.0
print(circle.diameter) // 10.0
circle.diameter = 12
print(circle.radius) // 6.0
print(circle.diameter) // 12.0
存储属性
1、类似于成员变量
2、存储在实例的内存中
3、结构体、类可以定义存储属性
4、枚举不可以定义存储属性
5、在创建类或结构体的实例时，必须为所有的存储属性设置一个合适的初始值。可以在初始化器里为存储属性设置一个初始值，也可以分配一个默认的属性值作为属性定义的一部分。
计算属性
1、本质就是方法（函数）
2、不占用实例的内存
3、枚举、结构体、类都可以定义计算属性
4、定义计算属性只能用 var，不能用 let。let 代表常量，值是一成不变的。计算属性的值是可能发生变化的，即使是只读计算属性（只有get，没有set）。
5、枚举原始值 rawValue 的本质是：只读计算属性。
enum TestEnum : Int {
case test1 = 1, test2 = 2, test3 = 3
var rawValue: Int {
switch self {
case .test1:
return 10
case .test2:
return 11
case .test3:
return 12
}
}
}
print(TestEnum.test3.rawValue) // 12
延迟存储属性
1、使用 lazy 可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化。
2、lazy 属性必须是 var，不能是 let。let 必须在实例的初始化方法完成之前就拥有值。
3、如果多条线程同时第一次访问 lazy 属性，无法保证属性只被初始化1次。
4、当结构体包含一个延迟存储属性时，只有 var 的结构体实例才能访问延迟存储属性，因为延迟属性初始化时需要改变结构体的内存。
属性观察器（willSet 和 didSet）
1、可以给存储属性添加属性观察器。
2、willSet 会传递新值，默认叫 newValue。didSet 会传递旧值，默认叫 oldValue。
3、在初始化器中设置属性值不会触发 willSet 和 didSet。
4、在属性定义时设置初始值也不会触发 willSet 和 didSet。
5、属性观察器、计算属性，可以应用在全局变量、局部变量。
inout 的本质
1、如果实参有物理内存地址且没有设置属性观察器，直接将实参的内存地址传入函数（实参进行引用传递）。
2、如果实参是计算属性或者设置了属性观察器，采取了 Copy In Copy Out 的做法。
调用该函数时，先复制实参的值，产生副本【get】。
将副本的内存地址传入函数（副本进行引用传递），在函数内部可以修改副本的值。
函数返回后，再将副本的值覆盖实参的值【set】。
3、总结：inout的本质就是引用传递（地址传递）。
2、类型属性
可以通过 static 定义类型属性，如果是类，也可以用关键字 class。
struct Car {
static var count: Int = 0
init() {
Car.count += 1
}
}
let c1 = Car()
let c2 = Car()
let c3 = Car()
print(Car.count) // 3
类型属性特点
1、不同于存储实例属性，必须给存储类型属性设定初始值。因为类型没有像实例那样的 init 初始化器来初始化存储属性。
2、存储类型属性默认就是 lazy，会在第一次使用的时候才初始化。就算被多个线程同时访问，保证只会初始化一次。
3、存储类型属性可以是 let。
4、枚举类型也可以定义类型属性（存储类型属性、计算类型属性）。
单例模式
//示例一
public class FileManager {
public static let shared = FileManager()
private init() { }
}
//示例二
public class FileManager {
public static let shared = {
// ....
// ....
return FileManager()
}()
private init() { }
}
2、方法
枚举、结构体、类都可以定义实例方法、类型方法。
实例方法（Instance Method）：通过实例对象调用。
类型方法（Type Method）：通过类型调用，可以用 static 或者 class 关键字定义。
class Car {
static var cout = 0
init() {
Car.cout += 1
}
static func getCount() -> Int { cout }
}
let c0 = Car()
let c1 = Car()
let c2 = Car()
print(Car.getCount()) // 3
self：在实例方法中代表实例对象，在类型方法中代表类型。
mutating
结构体和枚举是值类型，默认情况下，值类型的属性不能被自身的实例方法修改。在 func 关键字前加 mutating 可以允许这种修改行为。
struct Point {
var x = 0.0, y = 0.0
mutating func moveBy(deltaX: Double, deltaY: Double) {
x += deltaX
y += deltaY
// self = Point(x: x + deltaX, y: y + deltaY)
}
}
enum StateSwitch {
case low, middle, high
mutating func next() {
switch self {
case .low:
self = .middle
case .middle:
self = .high
case .high:
self = .low
}
}
}
@discardableResult
在 func 前面加个 @discardableResult，可以消除函数调用后返回值未被使用的警告⚠️。
3、下标
1、使用 subscript 可以给任意类型（枚举、结构体、类）增加下标功能，subscript 的语法类似于实例方法、计算属性，其本质就是方法（函数）。
2、subscript 中定义的返回值类型决定了 get 方法的返回值类型、set 方法中 newValue 的类型。
3、subscript 可以接受多个参数，并且类型任意。
class Point {
var x = 0.0, y = 0.0
subscript(index: Int) -> Double {
set {
if index == 0 {
x = newValue
} else if index == 1 {
y = newValue
}
}
get {
if index == 0 {
return x
} else if index == 1 {
return y
}
return 0
}
}
}
var p = Point()
p[0] = 11.1
p[1] = 22.2
print(p.x) // 11.1
print(p.y) // 22.2
print(p[0]) // 11.1
print(p[1]) // 22.2
1、subscript 可以没有 set 方法，但必须要有 get 方法。
class Point {
var x = 0.0, y = 0.0
subscript(index: Int) -> Double {
get {
if index == 0 {
return x
} else if index == 1 {
return y
}
return 0
}
}
}
2、如果只有 get 方法，可以省略 get。
class Point {
var x = 0.0, y = 0.0
subscript(index: Int) -> Double {
if index == 0 {
return x
} else if index == 1 {
return y
}
return 0
}
}
3、可以设置参数标签
class Point {
var x = 0.0, y = 0.0
subscript(index i: Int) -> Double {
if i == 0 {
return x
} else if i == 1 {
return y
}
return 0
}
}
var p = Point()
p.y = 22.2
print(p[index: 1]) // 22.2
4、下标可以是类型方法
class Sum {
static subscript(v1: Int, v2: Int) -> Int {
return v1 + v2
}
}
print(Sum[10, 20]) // 30
5、接收多个参数的下标
class Grid {
var data = [
[0, 1, 2],
[3, 4, 5],
[6, 7, 8]
]
subscript(row: Int, column: Int) -> Int {
set {
guard row >= 0 && row < 3 && column >= 0 && column < 3 else {return}
data[row][column] = newValue
}
get {
guard row >= 0 && row < 3 && column >= 0 && column < 3 else {return 0}
return data[row][column]
}
}
}
var grid = Grid()
grid[0, 1] = 77
grid[1, 2] = 88
grid[2, 0] = 99
print(grid.data)
4、继承
1、值类型（枚举、结构体）不支持继承，只有类支持继承。
2、没有父类的类，称为基类。Swift 并没有像 OC 那样的规定：任何类最终都要继承自某个基类。
3、子类可以重写父类的下标、方法、属性，重写必须加上 override 关键字。
1、重写实例方法、下标
class Animal {
func speak() {
print("Animal speak")
}
subscript(index: Int) -> Int {
return index
}
}
var anim: Animal
anim = Animal()
// Animal speak
anim.speak()
// 6
print(anim[6])
class Cat : Animal {
override func speak() {
super.speak()
print("Cat speak")
}
override subscript(index: Int) -> Int {
return super[index] + 1
}
}
anim = Cat()
// Animal speak
// Cat speak
anim.speak()
// 7
print(anim[6])
2、重写类型方法、下标
被 class 修饰的类型方法、下标，允许被子类重写；被 static 修饰的类型方法、下标，不允许被子类重写。
class Animal {
class func speak() {
print("Animal speak")
}
class subscript(index: Int) -> Int {
return index
}
}
// Animal speak
Animal.speak()
// 6
print(Animal[6])
class Cat : Animal {
override class func speak() {
super.speak()
print("Cat speak")
}
override class subscript(index: Int) -> Int {
return super[index] + 1
}
}
// Animal speak
// Cat speak
Cat.speak()
// 7
print(Cat[6])
3、重写属性
1、子类可以将父类的属性（存储、计算）重写为计算属性。
2、子类不可以将父类属性重写为存储属性。
3、只能重写 var 属性，不能重写 let 属性。
4、重写时，属性名、类型要一致。
5、子类重写后的属性权限不能小于父类属性的权限。如果父类属性是只读的，那么子类重写后的属性可以是只读的、也可以是可读写的；如果父类属性是可读写的，那么子类重写后的属性也必须是可读写的。
4、重写类型属性
被 class 修饰的计算类型属性，可以被子类重写；被 static 修饰的类型属性（存储、计算），不可以被子类重写。
5、属性观察器
可以在子类中为父类属性（除了只读计算属性、let 属性）增加属性观察器。
6、final
1、被 final 修饰的方法、下标、属性，禁止被重写。
2、被 final 修饰的类，禁止被继承。
5、初始化
类、结构体、枚举都可以定义初始化器。
类有 2 种初始化器：指定初始化器（designated initializer）、便捷初始化器（convenience initializer）。
// 指定初始化器
init(parameters) {
//statements
}
// 便捷初始化器
convenience init(parameters) {
//statements
}
指定初始化器
1、每个类至少有一个指定初始化器，指定初始化器是类的主要初始化器。
2、默认初始化器总是类的指定初始化器。
3、类偏向于少量指定初始化器，一个类通常只有一个指定初始化器。
初始化器的相互调用规则：
1、指定初始化器必须从它的直系父类调用指定初始化器。
2、便捷初始化器必须从相同的类里调用另一个初始化器。
3、便捷初始化器最终必须调用一个指定初始化器。
1、两段式初始化和安全检查
Swift 为了保证初始化过程的安全，设定了两段式初始化、 安全检查。
两段式初始化
第1阶段：初始化所有存储属性
1、外层调用指定\便捷初始化器。
2、分配内存给实例，但未初始化。
3、指定初始化器确保当前类定义的存储属性都初始化。
4、指定初始化器调用父类的初始化器，不断向上调用，形成初始化器链。
第2阶段：设置新的存储属性值
1、从顶部初始化器往下，链中的每一个指定初始化器都有机会进一步定制实例。
2、初始化器现在能够使用 self（访问、修改它的属性，调用它的实例方法等等）。
3、最终，链中任何便捷初始化器都有机会定制实例以及使用 self。
安全检查
1、指定初始化器必须保证在调用父类初始化器之前，其所在类定义的所有存储属性都要初始化完成。
2、指定初始化器必须先调用父类初始化器，然后才能为继承的属性设置新值。
3、便捷初始化器必须先调用同类中的其它初始化器，然后再为任意属性设置新值。
4、初始化器在第1阶段初始化完成之前，不能调用任何实例方法、不能读取任何实例属性的值，也不能引用 self。
5、直到第1阶段结束，实例才算完全合法。
2、重写
1、当重写父类的指定初始化器时，必须加上 override（即使子类的实现是便捷初始化器）。
2、如果子类写了一个匹配父类便捷初始化器的初始化器，不用加上 override。因为父类的便捷初始化器永远不会通过子类直接调用，因此，严格来说，子类无法重写父类的便捷初始化器。
3、自动继承
1、如果子类没有自定义任何指定初始化器，它会自动继承父类所有的指定初始化器。
2、如果子类提供了父类所有指定初始化器的实现（要么通过方式 1 继承，要么重写）。子类自动继承所有的父类便捷初始化器。
3、就算子类添加了更多的便捷初始化器，这些规则仍然适用。
4、子类以便捷初始化器的形式重写父类的指定初始化器，也可以作为满足规则 2 的一部分。
4、required
用 required 修饰指定初始化器，表明其所有子类都必须实现该初始化器（通过继承或者重写实现）。如果子类重写了 required 初始化器，也必须加上 required，不用加 override。
class Person {
required init() { }
init(age: Int) { }
}
class Student : Person {
required init() {
super.init()
}
}
5、属性观察器
父类的属性在它自己的初始化器中赋值不会触发属性观察器，但在子类的初始化器中赋值会触发属性观察器。
6、可失败初始化器
类、结构体、枚举都可以使用 init? 定义可失败初始化器。
class Person {
var name: String
init?(name: String) {
if name.isEmpty {
return nil
}
self.name = name
}
}
1、不允许同时定义参数标签、参数个数、参数类型相同的可失败初始化器和非可失败初始化器。
2、可以用 init! 定义隐式解包的可失败初始化器。
3、可失败初始化器可以调用非可失败初始化器，非可失败初始化器调用可失败初始化器需要进行解包。
4、如果初始化器调用一个可失败初始化器导致初始化失败，那么整个初始化过程都失败，并且之后的代码都停止执行。
5、可以用一个非可失败初始化器重写一个可失败初始化器，但反过来是不行的。
7、反初始化器（deinit）
1、deinit 叫做反初始化器，类似于 OC 中的 dealloc 方法。当类的实例对象被释放内存时，就会调用实例对象的 deinit 方法。
2、deinit 不接受任何参数，不能写小括号，不能自行调用。父类的 deinit 能被子类继承。子类的 deinit 实现执行完毕后会调用父类的 deinit。
6、可选链
1、如果可选项为 nil，调用方法、下标、属性失败，结果为 nil。
2、如果可选项不为 nil，调用方法、下标、属性成功，结果会被包装成可选项。如果结果本来就是可选项，不会进行再次包装。
3、多个 ? 可以链接在一起，如果链中任何一个节点是 nil，那么整个链就会调用失败。