image.png
Swift 结构体和类
结构体
在 Swift 标准库中，绝大多数的公开类型都是结构体，而枚举和类只占很小一部分
比如Bool、Int、Double、 String、Array、Dictionary等常见类型都是结构体
1. 初始化器
所有的结构体都有一个编译器自动生成的初始化器(initializer，初始化方法、构造器、构造方法)
struct Date {
var year: Int
var month: Int
var day: Int
}
// 可以传入所有成员值，用以初始化所有成员(存储属性，Stored Property)
var date = Date(year: 2019, month: 06, day: 29)
如果给属性设置可选变量,则会生成多个构造器(初始化器)
struct Point {
var x: Int?
var y: Int?
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(y: 10)
var p3 = Point(x: 10)
var p4 = Point()
类
1. 类的初始化器
- 类的定义和结构体类似，但编译器并没有为类自动生成可以传入成员值的初始化器
- 如果类的所有成员都在定义的时候指定了初始值，编译器会为类生成无参的初始化器
class Point {
var x: Int = 0
var y: Int = 0
}
var point = Point()
2. 结构体与类的本质区别
结构体是值类型(枚举也是值类型)，类是引用类型(指针类型)
image.png
值类型
- 值类型赋值给var、let或者给函数传参，是直接将所有内容拷贝一份
- 类似于对文件进行copy、paste操作，产生了全新的文件副本。属于深拷贝(deep copy)
- 在Swift标准库中，为了提升性能，String、Array、Dictionary、Set采取了Copy On Write的技术
- 比如仅当有“写”操作时，才会真正执行拷贝操作
- 对于标准库值类型的赋值操作，Swift 能确保最佳性能，所有没必要为了保证最佳性能来避免赋值
- 建议:不需要修改的，尽量定义成let
引用类型
- 引用赋值给var、let或者给函数传参，是将内存地址拷贝一份
- 类似于制作一个文件的替身(快捷方式、链接)，指向的是同一个文件。属于浅拷贝(shallow copy)
Swift 属性
1. 存储属性&计算属性
Swift中跟实例对象相关的属性可以分为2大类
存储属性(Stored Property)
- 类似于成员变量这个概念
- 存储在实例对象的内存中
- 结构体、类可以定义存储属性
- 枚举不可以定义存储属性
计算属性(Computed Property)
- 本质就是方法(函数)
- 不占用实例对象的内存
- 枚举、结构体、类都可以定义计算属性
struct Circle {
// 存储属性
var radius: Double
// 计算属性
var diameter: Double {
set {
radius = newValue / 2
}
get {
return radius * 2
}
}
}
2. 计算属性
set传入的新值默认叫做newValue，也可以自定义
struct Circle {
var radius: Double
var diameter: Double {
set(newDiameter) {
radius = newDiameter / 2
}
get {
radius * 2 }
}
}
只读计算属性:只有get，没有set
struct Circle {
var radius: Double
var diameter: Double {
get {
radius * 2
}
}
}
- 定义计算属性只能用var，不能用let
- let代表常量:值是一成不变的
- 计算属性的值是可能发生变化的(即使是只读计算属性)
3. 枚举rawValue原理
枚举原始值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 }
}
}
4. 延迟存储属性(Lazy Stored Property)
使用lazy可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化
- lazy属性必须是var，不能是let
- let必须在实例对象的初始化方法完成之前就拥有值
- 如果多条线程同时第一次访问lazy属性
- 无法保证属性只被初始化1次
class PhotoView {
lazy var image: Image = {
let url = "https://www.../xx.png"
let data = Data(url: url)
return Image(data: data)
}()
}
5. 属性观察器(Property Observer)
可以为非lazy的var存储属性设置属性观察器
struct Circle {
var radius: Double {
willSet {
print("willSet", newValue)
}
didSet {
print("didSet", oldValue, radius)
}
}
init() {
self.radius = 1.0
print("Circle init!")
}
}
- willSet会传递新值，默认叫newValue
- didSet会传递旧值，默认叫oldValue
- 在初始化器中设置属性值不会触发willSet和didSet
6.类型属性(Type Property)
严格来说，属性可以分为
实例属性(Instance Property): 只能通过实例对象去访问
- 存储实例属性(Stored Instance Property):存储在实例对象的内存中，每个实例对象都有1份
- 计算实例属性(Computed Instance Property)
类型属性(Type Property):只能通过类型去访问
- 存储类型属性(Stored Type Property):整个程序运行过程中，就只有1份内存(类似于全局变量)
- 计算类型属性(Computed Type Property)
可以通过static定义类型属性 p如果是类，也可以用关键字class
struct Car {
static var count: Int = 0
init() {
Car.count += 1
}
}
不同于存储实例属性，你必须给存储类型属性设定初始值
- 因为类型没有像实例对象那样的init初始化器来初始化存储属性
存储类型属性默认就是lazy，会在第一次使用的时候才初始化
- 就算被多个线程同时访问，保证只会初始化一次
- 存储类型属性可以是let
枚举类型也可以定义类型属性(存储类型属性、计算类型属性)
7. 单例模式
通过 类型属性+let+private 来写单例;
public class FileManager {
public static let shared = {
// ....
// ....
return FileManager()
}()
private init() { }
}
Swift 方法
枚举、结构体、类都可以定义实例方法、类型方法
- 实例方法(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
1.在实例方法中代表实例对象
2.在类型方法中代表类型
在类型方法static func getCount中
cout等价于self.cout、Car.self.cout、Car.cout
1.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)
} }
2. @discardableResult
在func前面加个@discardableResult，可以消除:函数调用后返回值未被使用的警告
struct Point {
var x = 0.0, y = 0.0
@discardableResult mutating
func moveX(deltaX: Double) -> Double {
x += deltaX
return x }
}
var p = Point()
p.moveX(deltaX: 10)
@discardableResult
func get() -> Int {
return 10 }
get()
Swift 下标
使用subscript可以给任意类型(枚举、结构体、类)增加下标功能，有些地方也翻译为:下标脚本
- 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
- subscript中定义的返回值类型决定了
- get方法的返回值类型
- set方法中newValue的类型
- subscript可以接受多个参数，并且类型任意
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 }
} }
- 如果只有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
}
}
- 可以设置参数标签
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 }
}
- 下标可以是类型方法
class Sum {
static subscript(v1: Int, v2: Int) -> Int {
return v1 + v2
}
}
print(Sum[10, 20]) // 30
2. 接收多个参数的下标
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)
Swift 继承
- 值类型(枚举、结构体)不支持继承，只有类支持继承
- 没有父类的类，称为:基类 ,Swift并没有像OC、Java那样的规定:任何类最终都要继承自某个基类
- 子类可以重写父类的下标、方法、属性，重写必须加上override关键字
class Animal {
var age = 0
}
class Dog : Animal {
var weight = 0
}
class ErHa : Dog {
var iq = 0
}
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])
- 被class修饰的类型方法、下标，允许被子类重写
- 被static修饰的类型方法、下标，不允许被子类重写
2. 重写属性
- 子类可以将父类的属性(存储、计算)重写为计算属性
- 子类不可以将父类属性重写为存储属性
- 只能重写var属性，不能重写let属性
- 重写时，属性名、类型要一致
- 子类重写后的属性权限 不能小于 父类属性的权限
- 如果父类属性是只读的，那么子类重写后的属性可以是只读的、也可以是可读写的
- 如果父类属性是可读写的，那么子类重写后的属性也必须是可读写的
3. 属性观察器
可以在子类中为父类属性(除了只读计算属性、let属性)增加属性观察器
class Circle {
var radius: Int = 1
}
class SubCircle : Circle {
override var radius: Int {
willSet {
print("SubCircle willSetRadius", newValue) }
didSet {
print("SubCircle didSetRadius", oldValue, radius)
} }
}
var circle = SubCircle()
// SubCircle willSetRadius 10 // SubCircle didSetRadius 1 10 circle.radius = 10
class Circle {
var radius: Int = 1 {
willSet {
print("Circle willSetRadius", newValue)
} didSet {
print("Circle didSetRadius", oldValue, radius) }
}
}
class SubCircle : Circle {
override var radius: Int {
willSet {
print("SubCircle willSetRadius", newValue)
} didSet {
print("SubCircle didSetRadius", oldValue, radius) }
}
}
class Circle {
var radius: Int {
set {
print("Circle setRadius", newValue)
} get {
print("Circle getRadius")
return 20 }
}
}
class SubCircle : Circle {
override var radius: Int {
willSet {
print("SubCircle willSetRadius", newValue)
} didSet {
print("SubCircle didSetRadius", oldValue, radius) }
}
}
4. final
- 被final修饰的方法、下标、属性，禁止被重写
- 被final修饰的类，禁止被继承
Swift 初始化
1. 初始化器
类、结构体、枚举都可以定义初始化器
类有2种初始化器: 指定初始化器(designated initializer)、便捷初始化器(convenience initializer)
// 指定初始化器
init(parameters) {
statements
}
// 便捷初始化器
convenience init(parameters) {
statements
}
规则:
- 每个类至少有一个指定初始化器，指定初始化器是类的主要初始化器
- 默认初始化器总是类的指定初始化器
- 类偏向于少量指定初始化器，一个类通常只有一个指定初始化器
初始化器的相互调用规则
- 指定初始化器必须从它的直系父类调用指定初始化器
- 便捷初始化器必须从相同的类里调用另一个初始化器
- 便捷初始化器最终必须调用一个指定初始化器
// 便捷初始化器最终必须调用一个 指定初始化器,保证安全,保证所有属性都被初始化
class Person {
var name: String
var age: Int
var height: Int {
get {
return age*10;
}
}
// 指定初始化器
init(name: String, age: Int) {
self.name = name;
self.age = age;
}
// 便捷初始化器
convenience init(name: String){
self.init(name: name, age: 0);
}
// 便捷初始化器
convenience init (age: Int) {
self.init(name: "", age: age);
}
// 便捷初始化器
convenience init(){
self.init(name: "", age: 0);
}
}
var ppp = Person(age: 10);
var ppp1 = Person(name: "alex");
var PPP2 = Person(name: "alex", age: 10);
初始化器的相互调用
image.png
2. 两段式初始化
Swift在编码安全方面是煞费苦心，为了保证初始化过程的安全，设定了两段式初始化、 安全检查
两段式初始化
-
第1阶段:初始化所有存储属性
- 外层调用指定\便捷初始化器
- 分配内存给实例，但未初始化
- 指定初始化器确保当前类定义的存储属性都初始化
- 指定初始化器调用父类的初始化器，不断向上调用，形成初始化器链
-
第2阶段:设置新的存储属性值
- 从顶部初始化器往下，链中的每一个指定初始化器都有机会进一步定制实例
- 初始化器现在能够使用self(访问、修改它的属性，调用它的实例方法等等)
- 最终，链中任何便捷初始化器都有机会定制实例以及使用self
3. 安全检查
- 指定初始化器必须保证在调用父类初始化器之前，其所在类定义的所有存储属性都要初始化完成
- 指定初始化器必须先调用父类初始化器，然后才能为继承的属性设置新值
- 便捷初始化器必须先调用同类中的其它初始化器，然后再为任意属性设置新值
- 初始化器在第1阶段初始化完成之前，不能调用任何实例方法、不能读取任何实例属性的值，也不能引用self n 直到第1阶段结束，实例才算完全合法
4. 重写
- 当重写父类的指定初始化器时，必须加上override(即使子类的实现是便捷初始化器)
- 如果子类写了一个匹配父类便捷初始化器的初始化器，不用加上override
- 因为父类的便捷初始化器永远不会通过子类直接调用，因此，严格来说，子类无法重写父类的便捷初始化器
5.自动继承
- 如果子类没有自定义任何指定初始化器，它会自动继承父类所有的指定初始化器
- 如果子类提供了父类所有指定初始化器的实现(要么通过方式1继承，要么重写)
- 子类自动继承所有的父类便捷初始化器
- 就算子类添加了更多的便捷初始化器，这些规则仍然适用
- 子类以便捷初始化器的形式重写父类的指定初始化器，也可以作为满足规则2的一部分
6.required
- 用required修饰指定初始化器，表明其所有子类都必须实现该初始化器(通过继承或者重写实现)
- 如果子类重写了required初始化器，时也必须加上required，不用加override
class Person {
required init() { }
init(age: Int) { }
}
class Student: Person {
required init() {
super.init()
}
}
7.属性观察器
父类的属性在它自己的初始化器中赋值不会触发属性观察器，但在子类的初始化器中赋值会触发属性观察器
class Person {
var age: Int {
willSet {
print("willSet", newValue)
} didSet {
print("didSet", oldValue, age)
}
} init() {
self.age = 0 }
}
class Student: Person {
override init() {
super.init()
self.age = 1 }
}
// willSet 1
// didSet 0 1
var stu = Student()
8.可失败初始化器
类、结构体、枚举都可以使用init?定义可失败初始化器
class Person {
var name: String
init?(name: String) {
if name.isEmpty {
return nil
}
self.name = name
}
}
- 不允许同时定义参数标签、参数个数、参数类型相同的可失败初始化器和非可失败初始化器
- 可以用init!定义隐式解包的可失败初始化器
- 可失败初始化器可以调用非可失败初始化器，非可失败初始化器调用可失败初始化器需要进行解包
- 如果初始化器调用一个可失败初始化器导致初始化失败，那么整个初始化过程都失败，并且之后的代码都停止执行
- 可以用一个非可失败初始化器重写一个可失败初始化器，但反过来是不行的
9.反初始化器(deinit)
deinit叫做反初始化器，类似于C++的析构函数、OC中的dealloc方法
- 当类的实例对象被释放内存时，就会调用实例对象的deinit方法
class Person {
deinit {
print("Person对象销毁了")
}
}
- deinit不接受任何参数，不能写小括号，不能自行调用
- 父类的deinit能被子类继承
- 子类的deinit实现执行完毕后会调用父类的deinit
Swift 可选链
可选链是一个调用和查询可选属性、方法和下标的过程，它可能为 nil 。如果可选项包含值，属性、方法或者下标的调用成功；如果可选项是 nil ，属性、方法或者下标的调用会返回 nil 。多个查询可以链接在一起，如果链中任何一个节点是 nil ，那么整个链就会得体地失败。
class Car { var price = 0 }
class Dog { var weight = 0 }
class Person {
var name: String = ""
var dog: Dog = Dog()
var car: Car? = Car()
func age() -> Int {
return 18
}
func eat() {
print("Person eat")
}
subscript(index: Int) -> Int {
return index
}
}
var person: Person? = Person()
var age1 = person!.age() // Int
var age2 = person?.age() // Int?
var name = person?.name // String?
var index = person?[6] // Int?
func getName() -> String { return "jack" }
// 如果person是nil，不会调用getName()
person?.name = getName()
- 如果可选项为nil，调用方法、下标、属性失败，结果为nil
- 如果可选项不为nil，调用方法、下标、属性成功，结果会被包装成可选项
- 如果结果本来就是可选项，不会进行再次包装
var dog = person?.dog // Dog?
var weight = person?.dog.weight // Int?
var price = person?.car?.price // Int?
- 多个?可以链接在一起
- 如果链中任何一个节点是nil，那么整个链就会调用失败
